Како да направите веб-апликација користејќи Flask во Python 3

Авторот ја избра програмата Пишувај за донации.

Вовед

Flask е мала и лесна веб-рамка на Python која обезбедува корисни алатки и функции што го олеснуваат креирањето на веб-апликации во Python. Тоа им дава флексибилност на програмерите и е попристапна рамка за новите програмери бидејќи можете брзо да изградите веб-апликација користејќи само една датотека на Python. Колбата е исто така растеглива и не присилува одредена структура на директориумот или не бара комплициран код за котли пред да започнете.

Како дел од ова упатство, ќе ја користите алатката Bootstrap за да ја стилизирате вашата апликација за да биде визуелно попривлечна. Bootstrap ќе ви помогне да вградите одговорни веб-страници во вашата веб-апликација, така што исто така работи добро на мобилните прелистувачи без да пишувате свој HTML, CSS и JavaScript код за да ги постигнете овие цели. Пакетот со алатки ќе ви овозможи да се фокусирате на учење како функционира Flask.

Flask го користи моторот за шаблони Jinja за динамички да изгради HTML-страници користејќи познати концепти на Python како што се променливи, циклуси, списоци и така натаму. Ќе ги користите овие шаблони како дел од овој проект.

Во ова упатство, ќе изградите мал веб-блог користејќи Flask и SQLite во Python 3. Корисниците на апликацијата можат да ги видат сите објави во вашата база на податоци и да кликнат на насловот на објавата за да ја видат неговата содржина со можност за додавање нова објава во базата на податоци и уредете или избришете постоечка објава.

Предуслови

Пред да започнете да го следите ова упатство, ќе ви требаат:

Локална програмска околина на Python 3, следете го упатството за вашата дистрибуција во Како да инсталирате и поставите локално програмско опкружување за серијата Python 3 за вашата локална машина. Во ова упатство ќе го повикаме нашиот проектен директориум flask_blog.
Разбирање на концептите на Python 3, како што е Како да се кодира во серијата Python 3.

Чекор 1 - Инсталирање на колба

Во овој чекор, ќе ја активирате вашата Python околина и ќе го инсталирате Flask користејќи го инсталаторот на пакетот pip.

Ако веќе не сте ја активирале вашата програмска околина, проверете дали сте во директориумот на вашиот проект (flask_blog) и користете ја следнава команда за да ја активирате околината:

source env/bin/activate

Откако ќе се активира вашата програмска средина, вашиот промпт сега ќе има префикс env кој може да изгледа вака:

Овој префикс е показател дека околината env е моментално активна, која може да има друго име во зависност од тоа како сте ја именувале при креирањето.

Забелешка: можете да ја користите статијата „Вовед во инсталацијата на Git“ „Употреба и гранки“.

Ако користите Git, добра идеја е да го игнорирате новосоздадениот директориум env во вашата датотека .gitignore за да избегнете следење датотеки што не се поврзани со проектот.

Сега ќе инсталирате Python пакети и ќе го изолирате кодот на вашиот проект подалеку од главната инсталација на системот Python. Ќе го направите ова користејќи pip и python.

За да инсталирате Flask, извршете ја следнава команда:

pip install flask

Откако ќе заврши инсталацијата, извршете ја следнава команда за да ја потврдите инсталацијата:

python -c "import flask; print(flask.__version__)"

Го користите интерфејсот на командната линија python со опцијата -c за да го извршите кодот на Python. Следно, го увезувате пакетот flask со inport flask; потоа ја печатите верзијата Flask, која е обезбедена преку променливата flask.__version__.

Излезот ќе биде број на верзија сличен на следново:

Output
1.1.2

Ја создадовте проектната папка, виртуелна средина и инсталиравте Flask. Сега сте подготвени да продолжите со поставувањето на вашата основна апликација.

Чекор 2 - Креирање на основна апликација

Сега кога ја поставивте вашата програмска околина, ќе започнете да го користите Flask. Во овој чекор, ќе направите мала веб-апликација во датотеката Python и ќе ја стартувате за да го стартувате серверот, кој ќе прикаже некои информации на прелистувачот.

Во вашиот директориум flask_blog, отворете датотека со име hello.py за уредување, користете nano или вашиот омилен уредувач на текст:

nano hello.py

Оваа датотека hello.py ќе послужи како минимален пример за тоа како да се справите со барањата HTTP. Внатре во него, ќе го увезете објектот Flask и ќе создадете функција што враќа HTTP одговор. Напишете го следниов код во hello.py:

from flask import Flask

app = Flask(__name__)


@app.route('/')
def hello():
    return 'Hello, World!'

Во претходниот блок код, прво го увезувате објектот Flask од пакетот flask. Потоа го користите за да го креирате вашиот примерок на апликацијата Flask со името app. Ја пренесувате специјалната променлива __name__ која го содржи името на тековниот модул на Python. Се користи за да се каже примерот каде се наоѓа - ова ви треба бидејќи Flask поставува некои патеки зад сцената.

Откако ќе го креирате примерот апликација, го користите за справување со дојдовните веб-барања и испраќање одговори до корисникот. @app.route е декоратор кој ја претвора обичната Python функција во Flask функција за преглед, која ја конвертира повратната вредност на функцијата во одговор HTTP што ќе се прикаже од клиент HTTP , како што е веб-прелистувач. Ја пренесувате вредноста / на @app.route() за да означите дека оваа функција ќе одговори на веб-барањата за URL-то /, што е главниот URL.

Функцијата за преглед hello() ја враќа низата Здраво, свето! како одговор.

Зачувајте ја и затворете ја датотеката.

За да ја извршите вашата веб-апликација, прво ќе му кажете на Flask каде да ја најде апликацијата (датотеката hello.py во вашиот случај) со променливата на околината FLASK_APP:

export FLASK_APP=hello

Потоа стартувајте го во развојен режим со променливата на околината FLASK_ENV:

export FLASK_ENV=development

На крајот, стартувајте ја апликацијата користејќи ја командата flask run:

flask run

Откако апликацијата ќе работи, излезот ќе биде вака:

Output * Serving Flask app "hello" (lazy loading)
 * Environment: development
 * Debug mode: on
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 813-894-335

Претходниот излез има неколку информации, како што се:

Името на апликацијата што ја извршувате.
Околината во која се извршува апликацијата.
Режим за отстранување грешки: вклучено означува дека дебагерот Flask работи. Ова е корисно кога се развива бидејќи ни дава детални пораки за грешка кога работите тргнуваат наопаку, што го олеснува решавањето на проблемите.
Апликацијата работи локално на URL-то http://127.0.0.1:5000/, 127.0.0.1 е IP што го претставува localhost на вашата машина и :5000 е бројот на портата.

Отворете прелистувач и внесете ја URL-то http://127.0.0.1:5000/, ќе ја добиете низата Здраво, свето! како одговор, што потврдува дека вашиот апликацијата успешно работи.

Предупредување Flask користи едноставен веб-сервер за да ја опслужува нашата апликација во развојна средина, што исто така значи дека дебагерот на Flask работи за да ги олесни фаќањето грешки. Овој развоен сервер не треба да се користи при производство на распоредување. Погледнете го упатството за распоредување на Flask.

Сега можете да го оставите развојниот сервер да работи во терминалот и да отворите друг терминален прозорец. Преместете се во проектната папка каде што се наоѓа hello.py, активирајте ја виртуелната средина, поставете ги променливите на околината FLASK_ENV и FLASK_APP и продолжете до следните чекори. (Овие команди се наведени претходно во овој чекор.)

Забелешка: кога отворате нов терминал, важно е да запомните активирање на виртуелната средина и поставување на променливите на околината FLASK_ENV и FLASK_APP.

Додека развојниот сервер на апликацијата Flask веќе работи, не е можно да се изврши друга апликација Flask со истата команда flask run. Ова е затоа што flask run стандардно го користи бројот на портата 5000 и откако ќе се преземе, станува недостапно да се стартува друга апликација, така што ќе добиете грешка слична на следново:

OutputOSError: [Errno 98] Address already in use

За да го решите овој проблем, или запрете го серверот што моментално работи преку CTRL+C, а потоа повторно стартувајте го flask run или ако сакате да ги активирате двата во исто време, може да пренесе различен број на порта на аргументот -p, на пример, за да извршите друга апликација на портата 5001 користете ја следнава команда:

flask run -p 5001

Сега имате мала веб апликација Flask. Ја извршивте вашата апликација и прикажавте информации на веб-прелистувачот. Следно, ќе користите HTML-датотеки во вашата апликација.

Чекор 3 - Користење на HTML шаблони

Во моментов вашата апликација прикажува само едноставна порака без никаков HTML. Веб-апликациите главно користат HTML за прикажување информации за посетителот, така што сега ќе работите на инкорпорирање на HTML-датотеки во вашата апликација, кои може да се прикажат на веб-прелистувачот.

Flask обезбедува помошна функција render_template() која овозможува користење на моторот на шаблоните Jinja. Ова ќе го олесни управувањето со HTML со пишување на вашиот HTML-код во датотеките .html како и со користење на логика во вашиот HTML-код. Ќе ги користите овие HTML-датотеки, (шаблони) за да ги изградите сите ваши страници со апликации, како што е главната страница каде што ќе ги прикажувате тековните објави на блогот, страницата на објавата на блогот, страницата каде што корисникот може да додаде нова објава и така натаму.

Во овој чекор, ќе ја креирате вашата главна апликација Flask во нова датотека.

Прво, во директориумот flask_blog, користете nano или вашиот омилен уредник за да ја креирате и уредувате вашата датотека app.py. Ова ќе го задржи целиот код што ќе го користите за да ја креирате апликацијата за блогирање:

nano app.py

Во оваа нова датотека, ќе го увезете објектот Flask за да креирате примерок од апликацијата Flask како што правевте претходно. Исто така, ќе ја увезете помошната функција render_template() која ви овозможува да ги прикажувате датотеките со HTML шаблони што постојат во папката шаблони што ќе ја креирате. Датотеката ќе има единствена функција за преглед која ќе биде одговорна за справување со барањата до главната рута /. Додадете ја следнава содржина:

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def index():
    return render_template('index.html')

Функцијата за преглед index() го враќа резултатот од повикувањето render_template() со index.html како аргумент, ова кажува render_template( ) да барате датотека наречена index.html во папката шаблони. И папката и датотеката сè уште не постојат, ќе добиете грешка ако ја извршите апликацијата во овој момент. Сепак, ќе го извршите, така што сте запознаени со овој најчесто сретнуван исклучок. Потоа ќе го поправите со создавање на потребната папка и датотека.

Зачувајте и излезете од датотеката.

Запрете го серверот за развој во другиот терминал што ја извршува апликацијата hello со CTRL+C.

Пред да ја стартувате апликацијата, проверете дали правилно сте ја специфицирале вредноста за променливата на околината FLASK_APP, бидејќи повеќе не ја користите апликацијата здраво:

export FLASK_APP=app
flask run

Отворањето на URL-адресата http://127.0.0.1:5000/ во вашиот прелистувач ќе резултира со страницата за отстранување грешки што ќе ве информира дека шаблонот index.html не е пронајден. Ќе биде означена главната линија во кодот што е одговорна за оваа грешка. Во овој случај, тоа е линијата return render_template(index.html).

Ако кликнете на оваа линија, дебагерот ќе открие повеќе код за да имате повеќе контекст што ќе ви помогне да го решите проблемот.

За да ја поправите оваа грешка, креирајте директориум наречен шаблони во вашиот директориум flask_blog. Потоа во него, отворете датотека наречена index.html за уредување:

mkdir templates
nano templates/index.html

Следно, додадете го следниов HTML код во index.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>FlaskBlog</title>
</head>
<body>
   <h1>Welcome to FlaskBlog</h1>
</body>
</html>

Зачувајте ја датотеката и користете го вашиот прелистувач за повторно да отидете на http://127.0.0.1:5000/ или да ја освежите страницата. Овој пат прелистувачот треба да го прикаже текстот Добре дојдовте во FlaskBlog во ознака <h1>.

Покрај папката шаблони, веб-апликациите Flask, исто така, обично имаат папка static за хостирање на статични датотеки, како што се CSS-датотеки, датотеки JavaScript и слики што ги користи апликацијата.

Можете да креирате датотека со стилски лист style.css за да додадете CSS во вашата апликација. Прво, креирајте директориум наречен static во вашиот главен директориум flask_blog:

mkdir static

Потоа креирајте друг директориум наречен css во директориумот static за да ги хостирате датотеките .css. Ова обично се прави за да се организираат статични датотеки во посветени папки, како такви, датотеките JavaScript обично живеат во директориумот наречен js, сликите се ставаат во директориумот наречен слики (или img), и така натаму. Следната команда ќе го создаде директориумот css во директориумот статички:

mkdir static/css

Потоа отворете ја датотеката style.css во директориумот css за уредување:

nano static/css/style.css

Додајте го следново CSS правило во вашата датотека style.css:

h1 {
    border: 2px #eee solid;
    color: brown;
    text-align: center;
    padding: 10px;
}

Кодот CSS ќе додаде рамка, ќе ја смени бојата во кафеава, ќе го центрира текстот и ќе додаде мало полнење на ознаките <h1>.

Зачувајте ја и затворете ја датотеката.

Следно, отворете ја датотеката со шаблон index.html за уредување:

nano templates/index.html

Ќе додадете врска до датотеката style.css во делот <head> во датотеката со шаблон index.html:

. . .
<head>
    <meta charset="UTF-8">
    <link rel="stylesheet" href="{{ url_for('static', filename= 'css/style.css') }}">
    <title>FlaskBlog</title>
</head>
. . .

Овде ја користите помошната функција url_for() за да ја генерирате соодветната локација на датотеката. Првиот аргумент одредува дека се поврзувате со статична датотека, а вториот аргумент е патеката на датотеката во статичниот директориум.

Зачувајте ја и затворете ја датотеката.

По освежувањето на страницата со индекс на вашата апликација, ќе забележите дека текстот Добре дојдовте во FlaskBlog сега е во кафена боја, центриран и затворен во рамка.

Можете да го користите јазикот CSS за да ја стилизирате апликацијата и да ја направите попривлечна користејќи го вашиот сопствен дизајн. Меѓутоа, ако не сте веб-дизајнер или ако не сте запознаени со CSS, тогаш можете да го користите пакетот алатки Bootstrap, кој обезбедува лесни за употреба компоненти за стилизирање на вашата апликација. Во овој проект, ќе користиме Bootstrap.

Можеби сте претпоставувале дека правењето друг HTML шаблон би значело повторување на најголемиот дел од HTML-кодот што веќе го напишавте во шаблонот index.html. Можете да избегнете непотребно повторување на кодот со помош на датотека основен шаблон, од која ќе наследат сите ваши HTML-датотеки. Видете Наследување на шаблоните во Jinja за повеќе информации.

За да направите основен шаблон, прво креирајте датотека наречена base.html во вашиот директориум шаблони:

nano templates/base.html

Внесете го следниов код во вашиот шаблон base.html:

<!doctype html>
<html lang="en">
  <head>
    <!-- Required meta tags -->
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">

    <!-- Bootstrap CSS -->
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css" integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">

    <title>{% block title %} {% endblock %}</title>
  </head>
  <body>
    <nav class="navbar navbar-expand-md navbar-light bg-light">
        <a class="navbar-brand" href="{{ url_for('index')}}">FlaskBlog</a>
        <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarNav" aria-controls="navbarNav" aria-expanded="false" aria-label="Toggle navigation">
            <span class="navbar-toggler-icon"></span>
        </button>
        <div class="collapse navbar-collapse" id="navbarNav">
            <ul class="navbar-nav">
            <li class="nav-item active">
                <a class="nav-link" href="#">About</a>
            </li>
            </ul>
        </div>
    </nav>
    <div class="container">
        {% block content %} {% endblock %}
    </div>

    <!-- Optional JavaScript -->
    <!-- jQuery first, then Popper.js, then Bootstrap JS -->
    <script src="https://code.jquery.com/jquery-3.3.1.slim.min.js" integrity="sha384-q8i/X+965DzO0rT7abK41JStQIAqVgRVzpbzo5smXKp4YfRvH+8abtTE1Pi6jizo" crossorigin="anonymous"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.7/umd/popper.min.js" integrity="sha384-UO2eT0CpHqdSJQ6hJty5KVphtPhzWj9WO1clHTMGa3JDZwrnQq4sF86dIHNDz0W1" crossorigin="anonymous"></script>
    <script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js" integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM" crossorigin="anonymous"></script>
  </body>
</html>

Зачувајте ја и затворете ја датотеката откако ќе завршите со нејзино уредување.

Поголемиот дел од кодот во претходниот блок е стандарден HTML и кодот потребен за Bootstrap. Ознаките <meta> обезбедуваат информации за веб-прелистувачот, ознаката <link> ги поврзува датотеките на Bootstrap CSS и ознаките <script> се линкови до кодот JavaScript што овозможува некои дополнителни функции на Bootstrap, проверете ја документацијата за Bootstrap за повеќе.

Сепак, следните нагласени делови се специфични за моторот на шаблонот Jinja:

{% block title %} {% endblock %}: блок што служи како место за наслов, подоцна ќе го користите во други шаблони за дајте приспособен наслов за секоја страница во вашата апликација без да го препишувате целиот дел <head> секој пат.
{{ url_for(index)}}: Повик на функција што ќе го врати URL-то за функцијата за преглед index(). Ова е различно од претходниот повик url_for() што го користевте за поврзување на статична CSS-датотека, бидејќи за него е потребен само еден аргумент, што е името на функцијата за преглед, и наместо тоа, се поврзува маршрутата поврзана со функцијата на статична датотека.
{% блок содржина %} {% endblock %}: Друг блок што ќе се замени со содржина во зависност од детскиот шаблон ( шаблони што наследуваат од base.html) што ќе го отфрлат.

Сега кога имате основен шаблон, можете да го искористите тоа користејќи наследство. Отворете ја датотеката index.html:

nano templates/index.html

Потоа заменете ја неговата содржина со следново:

{% extends 'base.html' %}

{% block content %}
    <h1>{% block title %} Welcome to FlaskBlog {% endblock %}</h1>
{% endblock %}

Во оваа нова верзија на шаблонот index.html, ја користите ознаката {% extends %} за наследување од шаблонот base.html. Потоа го проширувате преку замена на блокот содржина во основниот шаблон со она што е внатре во блокот содржина во претходниот блок со кодови.

Овој блок содржина содржи ознака <h1> со текстот Добре дојдовте во FlaskBlog во блокот title, кој во turn го заменува оригиналниот блок title во шаблонот base.html со текстот Добре дојдовте во FlaskBlog. На овој начин, можете да избегнете повторување на истиот текст двапати, бидејќи функционира и како наслов за страницата и како наслов што се појавува под лентата за навигација наследена од основниот шаблон.

Наследувањето на шаблоните исто така ви дава можност повторно да го користите HTML-кодот што го имате во други шаблони (base.html во овој случај) без да мора да го повторувате секогаш кога е потребно.

Зачувајте ја и затворете ја датотеката и освежете ја индексната страница на вашиот прелистувач. Ќе ја видите вашата страница со лента за навигација и стилизиран наслов.

Сте користеле HTML шаблони и статични датотеки во Flask. Го користевте и Bootstrap за да започнете да го усовршувате изгледот на вашата страница и основен шаблон за да избегнете повторување на кодот. Во следниот чекор, ќе поставите база на податоци што ќе ги складира податоците за вашата апликација.

Чекор 4 - Поставување на базата на податоци

Во овој чекор, ќе поставите база на податоци за складирање на податоци, односно блог објави за вашата апликација. Исто така, ќе ја наполните базата на податоци со неколку примери за записи.

Ќе го користите ова упатство.

Прво, бидејќи податоците во SQLite се складираат во табели и колони, а бидејќи вашите податоци главно се состојат од објави на блогови, прво треба да креирате табела наречена posts со потребните колони. Ќе креирате датотека .sql која содржи SQL команди за креирање на табелата posts со неколку колони. Потоа ќе ја користите оваа датотека за да ја креирате базата на податоци.

Отворете датотека наречена schema.sql во вашиот директориум flask_blog:

nano schema.sql

Внесете ги следните SQL команди во оваа датотека:

DROP TABLE IF EXISTS posts;

CREATE TABLE posts (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
    title TEXT NOT NULL,
    content TEXT NOT NULL
);

Зачувајте ја и затворете ја датотеката.

Првата команда на SQL е Drop TABLE IF EXISTS објави;, ова ги брише сите веќе постоечки табели со име posts за да не добиете збунувачки однесување. Имајте предвид дека ова ќе ја избрише целата содржина што ја имате во базата секогаш кога ги користите овие SQL команди, затоа погрижете се да не пишувате важна содржина во веб-апликацијата додека не го завршите ова упатство и експериментирате со конечниот резултат. Следно, CREATE TABLE објави се користи за креирање на табелата објави со следните колони:

id: Цел број што претставува примарен клуч, ќе добие единствена вредност од базата на податоци за секој запис (тоа е објава на блог). li>
создаден: времето во кое е креиран објавата на блогот. NOT NULL значи дека оваа колона не треба да биде празна, а вредноста DEFAULT е вредноста CURRENT_TIMESTAMP, што е времето во кое е додадена објавата до базата на податоци. Исто како id, не треба да наведете вредност за оваа колона, бидејќи таа автоматски ќе се пополнува.
наслов: Насловот на објавата.
содржина: содржината на објавата.

Сега кога имате SQL шема во датотеката schema.sql, ќе ја користите за да ја креирате базата на податоци користејќи Python-датотека која ќе генерира датотека со база на податоци SQLite .db . Отворете датотека со име init_db.py во директориумот flask_blog користејќи го претпочитаниот уредувач:

nano init_db.py

И потоа додадете го следниот код.

import sqlite3

connection = sqlite3.connect('database.db')


with open('schema.sql') as f:
    connection.executescript(f.read())

cur = connection.cursor()

cur.execute("INSERT INTO posts (title, content) VALUES (?, ?)",
            ('First Post', 'Content for the first post')
            )

cur.execute("INSERT INTO posts (title, content) VALUES (?, ?)",
            ('Second Post', 'Content for the second post')
            )

connection.commit()
connection.close()

Прво го увезувате модулот sqlite3, а потоа отворате врска со датотека со база на податоци именувана database.db, која ќе се креира откако ќе ја извршите датотеката Python. Потоа ја користите функцијата open() за да ја отворите датотеката schema.sql. Следно, ќе ја извршите неговата содржина користејќи го методот execute() за да извршите две INSERT SQL изјави за да додадете две објави на блогот на вашата табела објави. Конечно, ги извршувате промените и ја затворате врската.

Зачувајте ја и затворете ја датотеката и потоа стартувајте ја во терминалот користејќи ја командата python:

python init_db.py

Откако датотеката ќе заврши со извршување, нова датотека наречена database.db ќе се појави во вашиот директориум flask_blog. Ова значи дека успешно сте ја поставиле вашата база на податоци.

Во следниот чекор, ќе ги вратите објавите што сте ги внеле во вашата база на податоци и ќе ги прикажете на почетната страница на вашата апликација.

Чекор 5 - Прикажување на сите објави

Сега кога ја поставивте вашата база на податоци, сега можете да ја менувате функцијата за преглед index() за да ги прикажете сите објави што ги имате во вашата база на податоци.

Отворете ја датотеката app.py за да ги направите следните измени:

nano app.py

За вашата прва модификација, ќе го увезете модулот sqlite3 на врвот на датотеката:

import sqlite3
from flask import Flask, render_template

. . .

Следно, ќе креирате функција што создава врска со базата на податоци и ќе ја вратите. Додадете го директно по увозот:

. . .
from flask import Flask, render_template

def get_db_connection():
    conn = sqlite3.connect('database.db')
    conn.row_factory = sqlite3.Row
    return conn

. . .

Оваа функција get_db_connection() отвора врска со датотеката со база на податоци database.db, а потоа го поставува атрибутот row_factory на sqlite3.Row за да можете да имате пристап заснован на имиња до колоните. Ова значи дека врската со базата на податоци ќе врати редови кои се однесуваат како обични речници на Python. И на крај, функцијата го враќа објектот за поврзување conn што ќе го користите за пристап до базата на податоци.

Откако ќе ја дефинирате функцијата get_db_connection(), изменете ја функцијата index() да изгледа вака:

. . .

@app.route('/')
def index():
    conn = get_db_connection()
    posts = conn.execute('SELECT * FROM posts').fetchall()
    conn.close()
    return render_template('index.html', posts=posts)

Во оваа нова верзија на функцијата index(), прво отворате врска со базата на податоци користејќи ја функцијата get_db_connection() што ја дефиниравте претходно. Потоа извршувате SQL барање за да ги изберете сите записи од табелата posts. Го имплементирате методот fetchall() за да ги преземете сите редови од резултатот од барањето, ова ќе ви врати листа на објави што сте ги вметнале во базата на податоци во претходниот чекор.

Ја затворате врската со базата на податоци користејќи го методот close() и го враќате резултатот од прикажувањето на шаблонот index.html. Исто така, како аргумент го пренесувате објектот posts, кој ги содржи резултатите што ги добивте од базата на податоци, тоа ќе ви овозможи пристап до објавите на блогот во шаблонот index.html.

Со овие измени, зачувајте ја и затворете ја датотеката app.py.

Сега, кога сте ги пренеле објавите што сте ги донеле од базата на податоци во шаблонот index.html, можете да користите јамка за за да ја прикажете секоја објава на вашата индексна страница.

Отворете ја датотеката index.html:

nano templates/index.html

Потоа, изменете го за да изгледа вака:

{% extends 'base.html' %}

{% block content %}
    <h1>{% block title %} Welcome to FlaskBlog {% endblock %}</h1>
    {% for post in posts %}
        <a href="#">
            <h2>{{ post['title'] }}</h2>
        </a>
        <span class="badge badge-primary">{{ post['created'] }}</span>
        <hr>
    {% endfor %}
{% endblock %}

Овде, синтаксата {% за објавата во објави %} е јамка Jinja for, која е слична на јамката за на Python, освен што ја подоцна мора да се затвори со синтаксата {% endfor %}. Ја користите оваа синтакса за да ја превртите секоја ставка во списокот posts што е пренесена од функцијата index() во линијата return render_template(index.html, објави =пости). Внатре во оваа јамка for, го прикажувате насловот на објавата во заглавие <h2> во ознаката <a> (подоцна ќе го користите ова означете за да се поврзете со секоја објава поединечно).

Насловот го прикажувате користејќи буквален разгранич на променлива ({{ ... }}). Запомнете дека објавата ќе биде објект сличен на речник, така што ќе можете да пристапите до насловот на објавата со post[title]. Исто така, го прикажувате датумот на создавање објава користејќи го истиот метод.

Откако ќе завршите со уредување на датотеката, зачувајте ја и затворете ја. Потоа одете на страницата со индекс во вашиот прелистувач. Ќе ги видите двете објави што ги додадовте во базата на податоци на вашата страница.

Сега, откако ја изменивте функцијата за преглед index() за да ги прикажете сите објави што ги имате во базата на почетната страница на вашата апликација, ќе продолжите да ја прикажувате секоја објава на една страница и да им дозволите на корисниците да се поврзе до секоја поединечна објава.

Чекор 6 - Прикажување на една објава

Во овој чекор, ќе креирате нова рута на Flask со функција за преглед и нов HTML-шаблон за прикажување на поединечна објава на блог според нејзиниот ID.

До крајот на овој чекор, URL-то http://127.0.0.1:5000/1 ќе биде страница што ја прикажува првата објава (бидејќи го има ID 1 ). URL-адресата http://127.0.0.1:5000/ID ќе ја прикаже објавата со поврзаниот број ID доколку постои.

Отворете app.py за уредување:

nano app.py

Бидејќи ќе треба да добиете објава на блог според неговиот ID од базата на податоци на повеќе локации подоцна во овој проект, ќе создадете самостојна функција наречена get_post(). Можете да го наречете со предавање на ID и да ја вратите објавата на блогот поврзан со дадениот ID или да го натерате Flask да одговори со порака 404 Not Found ако објавата на блогот не постои.

За да одговорите со страница 404, треба да ја увезете библиотеката Werkzeug, која беше инсталирана заедно со Flask, на врвот на датотеката:

import sqlite3
from flask import Flask, render_template
from werkzeug.exceptions import abort

. . .

Потоа, додадете ја функцијата get_post() веднаш по функцијата get_db_connection() што ја создадовте во претходниот чекор:

. . .

def get_db_connection():
    conn = sqlite3.connect('database.db')
    conn.row_factory = sqlite3.Row
    return conn


def get_post(post_id):
    conn = get_db_connection()
    post = conn.execute('SELECT * FROM posts WHERE id = ?',
                        (post_id,)).fetchone()
    conn.close()
    if post is None:
        abort(404)
    return post

. . .

Оваа нова функција има аргумент post_id што одредува која објава на блог да се врати.

Внатре во функцијата, ја користите функцијата get_db_connection() за да отворите врска со базата на податоци и да извршите SQL барање за да ја добиете објавата на блогот поврзан со дадената вредност post_id. Го додавате методот fetchone() за да го добиете резултатот и го складирате во променливата post, а потоа затворете ја врската. Ако променливата post има вредност Ништо, што значи дека не е пронајден резултат во базата на податоци, ја користите функцијата abort() што сте ја увезле претходно во одговорете со код за грешка 404 и функцијата ќе заврши со извршувањето. Меѓутоа, ако е пронајдена објава, ја враќате вредноста на променливата post.

Следно, додадете ја следнава функција за преглед на крајот од датотеката app.py:

. . .

@app.route('/<int:post_id>')
def post(post_id):
    post = get_post(post_id)
    return render_template('post.html', post=post)

Во оваа нова функција за преглед, додавате правило за променлива за да одредите дека делот после коса црта (/) е позитивен цел број (означен со конверторот int) до кој треба да пристапите во функцијата за преглед. Flask го препознава ова и ја пренесува својата вредност на аргументот за клучни зборови post_id на вашата функција за преглед post(). Потоа ја користите функцијата get_post() за да ја добиете објавата на блогот поврзан со наведениот ID и да го зачувате резултатот во променливата post, која ја пренесувате на објава .html шаблон што наскоро ќе го креирате.

Зачувајте ја датотеката app.py и отворете нова датотека со шаблон post.html за уредување:

nano templates/post.html

Внесете го следниов код во оваа нова датотека post.html. Ова ќе биде слично на датотеката index.html, освен што ќе прикажува само една објава, покрај тоа што ќе ја прикажува и содржината на објавата:

{% extends 'base.html' %}

{% block content %}
    <h2>{% block title %} {{ post['title'] }} {% endblock %}</h2>
    <span class="badge badge-primary">{{ post['created'] }}</span>
    <p>{{ post['content'] }}</p>
{% endblock %}

Го додавате блокот title што го дефиниравте во шаблонот base.html за насловот на страницата да го одразува насловот на објавата што е прикажан во <h2> се упатува во исто време.

Зачувајте ја и затворете ја датотеката.

Сега можете да отидете на следните URL-адреси за да ги видите двете објави што ги имате во вашата база на податоци, заедно со страница што му кажува на корисникот дека бараната објава на блогот не е пронајдена (бидејќи не постои објава со ID број 3 досега):

http://127.0.0.1:5000/1
http://127.0.0.1:5000/2
http://127.0.0.1:5000/3

Враќајќи се на страницата со индекс, ќе направите секој наслов на објава да се поврзе со неговата соодветна страница. Ќе го направите ова користејќи ја функцијата url_for(). Прво, отворете го шаблонот index.html за уредување:

nano templates/index.html

Потоа сменете ја вредноста на атрибутот href од # во {{ url_for(post, post_id=post[id]) }} така што Јамката for ќе изгледа токму вака:

{% for post in posts %}
    <a href="{{ url_for('post', post_id=post['id']) }}">
        <h2>{{ post['title'] }}</h2>
    </a>
    <span class="badge badge-primary">{{ post['created'] }}</span>
    <hr>
{% endfor %}

Овде, ја пренесувате пост на функцијата url_for() како прв аргумент. Ова е името на функцијата за преглед post() и бидејќи прифаќа аргумент post_id, му ја давате вредноста post[id]. Функцијата url_for() ќе ја врати соодветната URL-адреса за секоја објава врз основа на нејзиниот ID.

Зачувајте ја и затворете ја датотеката.

Врските на страницата со индекс сега ќе функционираат како што се очекуваше. Со ова, сега го завршивте градењето на делот од апликацијата одговорен за прикажување на објавите на блогот во вашата база на податоци. Следно, ќе ја додадете можноста за креирање, уредување и бришење објави на блог во вашата апликација.

Чекор 7 - Измена на објави

Сега, кога завршивте со прикажување на објавите на блогот што се присутни во базата на податоци на веб-апликацијата, треба да им дозволите на корисниците на вашата апликација да пишуваат нови објави на блогови и да ги додадат во базата на податоци, да ги уредуваат постоечките и да ги бришат непотребните блог постови.

Креирање на нова објава

До овој момент, имате апликација која ги прикажува објавите во вашата база на податоци, но не обезбедува начин за додавање нова објава освен ако директно не се поврзете со базата на податоци на SQLite и не ја додадете рачно. Во овој дел, ќе креирате страница на која ќе можете да креирате објава со обезбедување на нејзиниот наслов и содржина.

Отворете ја датотеката app.py за уредување:

nano app.py

Прво, ќе го увезете следново од рамката Flask:

Глобалниот барање објект за пристап до дојдовните податоци за барање што ќе бидат доставени преку формулар HTML.
Функцијата url_for() за генерирање на URL-адреси.
Функцијата flash() за трепкање порака кога се обработува барање.
Функцијата redirect() за пренасочување на клиентот на друга локација.

Додајте го увозот во вашата датотека како што следува:

import sqlite3
from flask import Flask, render_template, request, url_for, flash, redirect
from werkzeug.exceptions import abort

. . .

Функцијата flash() складира блескави пораки во сесијата на прелистувачот на клиентот, што бара поставување таен клуч. Овој таен клуч се користи за обезбедување на сесии, кои му овозможуваат на Flask да запомни информации од едно барање до друго, како што е преместување од страницата со нова објава на страницата со индекс. Корисникот може да пристапи до информациите зачувани во сесијата, но не може да ги менува освен ако го има тајниот клуч, затоа никогаш не смеете да дозволите некој да пристапи до вашиот таен клуч. Видете ја документацијата на Flask за сесии за повеќе информации.

За да поставите таен клуч, ќе додадете конфигурација SECRET_KEY на вашата апликација преку објектот app.config. Додајте ја директно следејќи ја дефиницијата апликација пред да ја дефинирате функцијата за преглед index():

. . .
app = Flask(__name__)
app.config['SECRET_KEY'] = 'your secret key'


@app.route('/')
def index():
    conn = get_db_connection()
    posts = conn.execute('SELECT * FROM posts').fetchall()
    conn.close()
    return render_template('index.html', posts=posts)

. . .

Запомнете дека тајниот клуч треба да биде долга случајна низа.

Откако ќе поставите таен клуч, ќе создадете функција за преглед што ќе прикаже шаблон што прикажува формулар што можете да го пополните за да креирате нов блог пост. Додадете ја оваа нова функција на дното на датотеката:

. . .

@app.route('/create', methods=('GET', 'POST'))
def create():
    return render_template('create.html')

Ова создава рута /create која ги прифаќа и барањата GET и POST. Барањата GET се стандардно прифатени. За да прифатите и барања за POST, кои ги испраќа прелистувачот при поднесување формулари, ќе пренесете торка со прифатените типови барања до аргументот methods на @app.route() декоратор.

Зачувајте ја и затворете ја датотеката.

За да го креирате шаблонот, отворете датотека наречена create.html во вашата папка шаблони:

nano templates/create.html

Додадете го следниов код во оваа нова датотека:

{% extends 'base.html' %}

{% block content %}
<h1>{% block title %} Create a New Post {% endblock %}</h1>

<form method="post">
    <div class="form-group">
        <label for="title">Title</label>
        <input type="text" name="title"
               placeholder="Post title" class="form-control"
               value="{{ request.form['title'] }}"></input>
    </div>

    <div class="form-group">
        <label for="content">Content</label>
        <textarea name="content" placeholder="Post content"
                  class="form-control">{{ request.form['content'] }}</textarea>
    </div>
    <div class="form-group">
        <button type="submit" class="btn btn-primary">Submit</button>
    </div>
</form>
{% endblock %}

Повеќето од овој код е стандарден HTML. Ќе прикаже поле за внесување за насловот на објавата, област за текст за содржината на објавата и копче за поднесување на формуларот.

Вредноста на внесувањето на насловот на објавата е {{ request.form[title] }}, а областа за текст има вредност {{ request.form[content] }}, ова се прави за да не се изгубат податоците што ги внесувате доколку нешто тргне наопаку. На пример, ако напишете долга објава и заборавите да му дадете наслов, ќе се прикаже порака која ќе ве информира дека насловот е задолжителен. Ова ќе се случи без губење на објавата што ја напишавте бидејќи ќе се зачува во глобалниот објект request до кој имате пристап во вашите шаблони.

Сега, кога работи серверот за развој, користете го вашиот прелистувач за да отидете на рутата /create:

http://127.0.0.1:5000/create

Ќе видите страница Креирај нова објава со поле за наслов и содржина.

Овој формулар поднесува барање POST до вашата функција за преглед create(). Сепак, сè уште нема шифра за справување со барање POST во функцијата, така што ништо не се случува по пополнувањето на формуларот и неговото поднесување.

Ќе се справите со дојдовното барање POST кога ќе се поднесе формулар. Ќе го направите ова во функцијата за преглед create(). Можете одделно да се справите со барањето POST со проверка на вредноста на request.method. Кога неговата вредност е поставена на POST тоа значи дека барањето е барање POST, потоа ќе продолжите да ги извлекувате поднесените податоци, да ги потврдите и да ги вметнете во вашата база на податоци.

Отворете ја датотеката app.py за уредување:

nano app.py

Изменете ја функцијата за преглед create() за да изгледа точно како што следува:

. . .

@app.route('/create', methods=('GET', 'POST'))
def create():
    if request.method == 'POST':
        title = request.form['title']
        content = request.form['content']

        if not title:
            flash('Title is required!')
        else:
            conn = get_db_connection()
            conn.execute('INSERT INTO posts (title, content) VALUES (?, ?)',
                         (title, content))
            conn.commit()
            conn.close()
            return redirect(url_for('index'))

    return render_template('create.html')

Во изјавата if обезбедувате дека кодот што следи се извршува само кога барањето е барање POST преку споредбата request.method == POST.

Потоа ги извлекувате поднесените наслови и содржина од објектот request.form што ви дава пристап до податоците на формуларот во барањето. Ако насловот не е наведен, ќе се исполни условот ако не наслов, прикажувајќи порака до корисникот со известување дека насловот е потребен. Ако, пак, насловот е обезбеден, отворате врска со функцијата get_db_connection() и ги вметнувате насловот и содржината што сте ја примиле во табелата posts.

Потоа ги извршувате промените во базата на податоци и ја затворате врската. Откако ќе ја додадете објавата на блогот во базата на податоци, го пренасочувате клиентот на страницата со индекс со помош на функцијата redirect(), пренесувајќи му ја URL-адресата генерирана од функцијата url_for() со вредноста index како аргумент.

Зачувајте ја и затворете ја датотеката.

Сега, одете до рутата /create користејќи го вашиот веб-прелистувач:

http://127.0.0.1:5000/create

Пополнете го формуларот со наслов по ваш избор и одредена содржина. Откако ќе го поднесете формуларот, ќе ја видите новата објава наведена на страницата со индекс.

На крајот, ќе прикажете блеснати пораки и ќе додадете врска до лентата за навигација во шаблонот base.html за да имате лесен пристап до оваа нова страница. Отворете ја датотеката со шаблон:

nano templates/base.html

Уредете ја датотеката со додавање нова ознака <li> следејќи ја врската За во ознаката <nav>. Потоа додадете нова јамка за директно над блокот содржина за да се прикажат блеснатите пораки под лентата за навигација. Овие пораки се достапни во специјалната функција get_flashed_messages() која ја обезбедува Flask:

<nav class="navbar navbar-expand-md navbar-light bg-light">
    <a class="navbar-brand" href="{{ url_for('index')}}">FlaskBlog</a>
    <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarNav" aria-controls="navbarNav" aria-expanded="false" aria-label="Toggle navigation">
        <span class="navbar-toggler-icon"></span>
    </button>
    <div class="collapse navbar-collapse" id="navbarNav">
        <ul class="navbar-nav">
        <li class="nav-item">
            <a class="nav-link" href="#">About</a>
        </li>
        <li class="nav-item">
            <a class="nav-link" href="{{url_for('create')}}">New Post</a>
        </li>
        </ul>
    </div>
</nav>
<div class="container">
    {% for message in get_flashed_messages() %}
        <div class="alert alert-danger">{{ message }}</div>
    {% endfor %}
    {% block content %} {% endblock %}
</div>

Зачувајте ја и затворете ја датотеката. Лентата за навигација сега ќе има ставка Нова објава што се поврзува до рутата /create.

Уредување на објава

За блогот да биде ажуриран, ќе треба да можете да ги уредувате вашите постоечки објави. Овој дел ќе ве води низ креирање нова страница во вашата апликација за да се поедностави процесот на уредување на објава.

Прво, ќе додадете нова рута во датотеката app.py. Неговата функција за преглед ќе го добие ID на објавата што треба да се уреди, URL-то ќе биде во формат /post_id/edit со post_id променливата е ID на објавата. Отворете ја датотеката app.py за уредување:

nano app.py

Следно, додадете ја следнава функција за преглед edit() на крајот од датотеката. Уредувањето на постоечка објава е слично на создавање на нова, така што оваа функција за преглед ќе биде слична на функцијата за преглед create():

. . .

@app.route('/<int:id>/edit', methods=('GET', 'POST'))
def edit(id):
    post = get_post(id)

    if request.method == 'POST':
        title = request.form['title']
        content = request.form['content']

        if not title:
            flash('Title is required!')
        else:
            conn = get_db_connection()
            conn.execute('UPDATE posts SET title = ?, content = ?'
                         ' WHERE id = ?',
                         (title, content, id))
            conn.commit()
            conn.close()
            return redirect(url_for('index'))

    return render_template('edit.html', post=post)

Објавата што ја уредувате се одредува со URL-то и Flask ќе го предаде ID-бројот на функцијата edit() преку аргументот id. Ја додавате оваа вредност на функцијата get_post() за да ја преземете објавата поврзана со дадениот ID од базата на податоци. Новите податоци ќе дојдат во барање POST, кое се постапува во условот if request.method == POST.

Исто како кога креирате нова објава, прво ги извлекувате податоците од објектот request.form потоа трепкате порака ако насловот има празна вредност, во спротивно, отворате врска со базата на податоци. Потоа ја ажурирате табелата објави со поставување на нов наслов и нова содржина каде ID на објавата во базата е еднаков на ID што беше во URL-то.

Во случај на барање GET, прикажувате шаблон edit.html кој поминува во променливата post која ја содржи вратената вредност на get_post() функција. Ќе го користите ова за да ги прикажете постоечкиот наслов и содржина на страницата за уредување.

Зачувајте ја и затворете ја датотеката, а потоа креирајте нов шаблон edit.html:

nano templates/edit.html

Напишете го следниов код во оваа нова датотека:

{% extends 'base.html' %}

{% block content %}
<h1>{% block title %} Edit "{{ post['title'] }}" {% endblock %}</h1>

<form method="post">
    <div class="form-group">
        <label for="title">Title</label>
        <input type="text" name="title" placeholder="Post title"
               class="form-control"
               value="{{ request.form['title'] or post['title'] }}">
        </input>
    </div>

    <div class="form-group">
        <label for="content">Content</label>
        <textarea name="content" placeholder="Post content"
                  class="form-control">{{ request.form['content'] or post['content'] }}</textarea>
    </div>
    <div class="form-group">
        <button type="submit" class="btn btn-primary">Submit</button>
    </div>
</form>
<hr>
{% endblock %}

Зачувајте ја и затворете ја датотеката.

Овој код ја следи истата шема, освен за {{ request.form[title] или post[title] }} и {{ request.form[content] или post[content] }} синтакса. Ова ги прикажува податоците зачувани во барањето доколку постојат, инаку ги прикажува податоците од променливата post што е предадена на шаблонот што ги содржи тековните податоци на базата на податоци.

Сега, одете на следната URL адреса за да ја уредите првата објава:

http://127.0.0.1:5000/1/edit

Ќе видите страница Уреди \Прва објава.

Уредете ја објавата и испратете го формуларот, а потоа проверете дали објавата е ажурирана.

Сега треба да додадете врска што укажува на страницата за уредување за секоја објава на страницата со индекс. Отворете ја датотеката со шаблон index.html:

nano templates/index.html

Уредете ја датотеката за да изгледа точно како што следува:

{% extends 'base.html' %}

{% block content %}
    <h1>{% block title %} Welcome to FlaskBlog {% endblock %}</h1>
    {% for post in posts %}
        <a href="{{ url_for('post', post_id=post['id']) }}">
            <h2>{{ post['title'] }}</h2>
        </a>
        <span class="badge badge-primary">{{ post['created'] }}</span>
        <a href="{{ url_for('edit', id=post['id']) }}">
            <span class="badge badge-warning">Edit</span>
        </a>
        <hr>
    {% endfor %}
{% endblock %}

Зачувајте ја и затворете ја датотеката.

Овде додавате ознака <a> за да се поврзете со функцијата за преглед edit(), префрлајќи ја вредноста post[id] за да се поврзете до страницата за уредување на секоја објава со врската Уреди.

Бришење на објава

Понекогаш објавата повеќе не треба да биде јавно достапна, поради што функционалноста за бришење објава е клучна. Во овој чекор ќе ја додадете функцијата за бришење во вашата апликација.

Прво, ќе додадете нова рута /ID/delete која прифаќа POST барања, слична на функцијата за преглед edit(). Вашата нова функција за преглед delete() ќе го добие ID на објавата што треба да се избрише од URL-то. Отворете ја датотеката app.py:

nano app.py

Додадете ја следнава функција за преглед на дното на датотеката:

# ....

@app.route('/<int:id>/delete', methods=('POST',))
def delete(id):
    post = get_post(id)
    conn = get_db_connection()
    conn.execute('DELETE FROM posts WHERE id = ?', (id,))
    conn.commit()
    conn.close()
    flash('"{}" was successfully deleted!'.format(post['title']))
    return redirect(url_for('index'))

Оваа функција за преглед прифаќа само POST барања. Ова значи дека навигацијата до рутата /ID/delete на вашиот прелистувач ќе врати грешка бидејќи веб-прелистувачите стандардно ги поставуваат барањата GET.

Сепак, можете да пристапите до оваа рута преку формулар што испраќа барање за POST што поминува во ID на објавата што сакате да ја избришете. Функцијата ќе ја добие вредноста на ID и ќе ја користи за да ја добие објавата од базата на податоци со функцијата get_post().

Потоа отворате врска со база на податоци и извршувате команда DELETE FROM SQL за да ја избришете објавата. Ја извршувате промената во базата на податоци и ја затворате врската додека трепкате порака за да го информирате корисникот дека објавата е успешно избришана и го пренасочувате на страницата со индекс.

Имајте предвид дека не прикажувате датотека со шаблон, тоа е затоа што само ќе додадете копче Избриши на страницата за уредување.

Отворете ја датотеката со шаблон edit.html:

nano templates/edit.html

Потоа додадете ја следната ознака <form> по ознаката <hr> и директно пред линијата {% endblock %}:

<hr>

<form action="{{ url_for('delete', id=post['id']) }}" method="POST">
    <input type="submit" value="Delete Post"
            class="btn btn-danger btn-sm"
            onclick="return confirm('Are you sure you want to delete this post?')">
</form>

{% endblock %}

Го користите методот confirm() за да прикажете порака за потврда пред да го испратите барањето.

Сега одете повторно на страницата за уредување на објава на блог и обидете се да ја избришете:

http://127.0.0.1:5000/1/edit

На крајот од овој чекор, изворниот код на вашиот проект ќе изгледа како кодот на оваа страница.

Со ова, корисниците на вашата апликација сега можат да пишуваат нови објави на блог и да ги додаваат во базата на податоци, да ги уредуваат и бришат постоечките објави.

Заклучок

Овој туторијал ги воведе основните концепти на рамката Flask Python. Научивте како да направите мала веб-апликација, да ја извршите во сервер за развој и да му дозволите на корисникот да обезбеди сопствени податоци преку параметрите на URL-то и веб-формите. Го користевте и како да се користат односите со бази на податоци еден-на-многу со Flask и SQLite.

Можете дополнително да ја развивате оваа апликација со додавање на автентикација на корисникот, така што само регистрираните корисници можат да креираат и менуваат објави на блогот, исто така можете да додавате коментари и ознаки за секоја објава на блогот и да додавате прикачувања на датотеки за да им дадете на корисниците можност да вклучат слики во објавата. Видете ја документацијата на Flask за повеќе информации.

Flask има многу екстензии на Flask направени во заедницата. Следното е список на екстензии што може да размислите да ги користите за да го олесните процесот на развој:

Flask-Login: управува со сесијата на корисникот и се справува со најавувањето и одјавувањето и запомнувањето на најавените корисници.
SQLAlchemy, комплет алатки за Python SQL и Object Relational Mapper за интеракција со SQL бази на податоци.
Flask-Mail: помага во задачата за испраќање е-пораки во вашата апликација Flask.