Най-добрият начин да научите Django или всяко друго умение е като приложите знанията, които имате, като създадете функционални проекти.
Django е най-използваната рамка за уеб разработка на Python. Неговите вградени функции и голямото количество пакети на трети страни го превърнаха в една от най-обичаните уеб рамки по целия свят.
Той е бърз, надежден и има много вградени функции. Например система за удостоверяване на дупки, която ви позволява да се съсредоточите върху основните функции на вашето приложение. Освен това можете да инсталирате външни пакети, за да изпълнявате още по-сложни задачи, като Django-allauth, който ви позволява да регистрирате потребители с техните социални акаунти.
Но нека изложим някои факти. Джанго е толкова огромна рамка, че понякога е предизвикателство да започнете с нея.
Така че днес ще изградите от нулата напълно функционално Django приложение.
До края на този урок вие ще:
- Написахте приложение за съкращаване на URL адреси
- Разберете Django MVT модела
- Научихте работния процес за създаване на проект
Съдържание
Предварителни изисквания
Всички следващи изисквания не са задължителни и ще ви помогнат да следвате заедно с урока. Но ако нямате опит с някое от тях, не се притеснявайте. Най-важната стъпка е първата.
- Основно разбиране на UNIX команди (l, cd, rm, touch)
- Основно разбиране на класовете и функциите на Python
- Python, инсталиран на вашия компютър (може би очевидно, но трябваше да го включа)
- Би било чудесно, ако вече сте създали нещо с Django
Целият работен код ще бъде достъпен на това Github репо.
Сега, след като имате кристално ясна предходна концепция, нека навлезем в въпроса.
Декларация на проекта
В този урок ще създадете програма за съкращаване на URL адреси. По принцип програмата за съкращаване на URL адреси е услуга, която взема дълъг URL адрес и го превръща в компактен.
Например, ако искате да споделите туит и искате да включите връзка към уебсайта си, но сте изправени пред ограничението за знаци, можете да използвате програма за съкращаване на URL адреси.
Нека го видим с графика.
Както можете да видите, програмата за съкращаване на URL адреси получава дълъг URL адрес и връща кратък. Точно това ще построите днес.
С този проект ще практикувате използването на модела MVT, ще научите основите на дизайна на бази данни с Django модели и ще научите как да показвате информация на потребителя чрез изгледи, URL адреси и шаблони.
Структура на Django проект
По принцип уебсайтът на Django е изграден върху един проект и множество отделни приложения. Всяко едно от тези приложения има специфична функционалност и може да работи самостоятелно.
Нека си представим сложно уеб приложение като Stackoverflow. Функционалността му се основава на два основни аспекта.
- Управление на потребителите: Вход, Изход, Репутация, Разрешения
- Форум: Въпроси, отговори, етикети, филтри
Следвайки структурата на уебсайта на Django, проектът ще бъде наречен StackOverflow, който има две основни приложения. Приложението за потребителите и приложението за форум.
Всяко от тези приложения има самостоятелна функционалност. Това означава, че и двете съдържат целия код, който им е необходим, за да работят правилно.
Това включва модели (структура на база данни), изгледи (заявки и отговори), специфични URL модели и, разбира се, шаблони и статични файлове (изображения, CSS, JavaScript). Това означава, че всяко приложение на Django може да се използва повторно, тъй като те могат да работят сами.
Съкратено, проектът се отнася до набор от конфигурации и приложения, които са предназначени за изграждане на уеб приложение. От друга страна, приложението Django е част от проект, който е самостоятелен (има всичко необходимо за работа) и целта му е да извърши определена операция.
Настройте Django проект
В този раздел ще настроите Django проект. За тази цел ще използвате различни инструменти като виртуална среда, за да организирате зависимостите на Python и най-важните Django скриптове. Django-admin и manage.py
Виртуална среда
Винаги препоръчвам да работите с виртуални среди когато създавате приложения с Django. Това е най-ефективният начин за поддържане на определен набор от зависимости. Но основната му цел е да изолира пакетите за разработка от глобалните.
И така, нека създадем виртуална среда с вградената команда за формуляр на python.
Забележка: Този метод изисква Python 3.6 или по-нови версии, за да работи.
python -m venv .venv
Тази команда използва командата python -m или python –mod. По същество той изпълнява модул или библиотека като скрипт. Според значението на тази команда, venv е библиотеката, която изпълняваме, а .venv се отнася до името на виртуалната среда, която искаме да създадем.
Така че на разбираем език тази команда означава.
Хей, Python, стартирай като скрипт вградената библиотека venv и създай име на virtualenv .venv
Сега е време да активираме виртуалната среда, която току-що създадохме, със следната команда.
source .venv/bin/activate
За да потвърдите, че нямате инсталирани пакети в новия venv, стартирайте.
pip freeze
Ако сте активирали виртуалната среда правилно, няма да получите никакъв резултат. Това е така, защото все още не сме инсталирали нищо.
Да влезем в Django
За да създадем нашето приложение за съкращаване на URL адреси, ще започнем с инсталирането на пакета Django. Django е пакет на трета страна, следователно трябва да го инсталираме с Pip (Pip инсталира пакети).
$ pip install django
Collecting django
Downloading Django-3.2.1-py3-none-any.whl (7.9 MB)
|████████████████████████████████| 7.9 MB 344 kB/s
Collecting asgiref<4,>=3.3.2
Using cached asgiref-3.3.4-py3-none-any.whl (22 kB)
Collecting sqlparse>=0.2.2
Using cached sqlparse-0.4.1-py3-none-any.whl (42 kB)
Collecting pytz
Using cached pytz-2021.1-py2.py3-none-any.whl (510 kB)
Installing collected packages: asgiref, sqlparse, pytz, django
Successfully installed asgiref-3.3.4 django-3.2.1 pytz-2021.1 sqlparse-0.4.1
Забележка: Не забравяйте, че $ не е нищо друго освен символ на обвивката.
За да проверим дали инсталацията е преминала правилно, проверяваме отново инсталираните пакети на нашия venv.
$ pip freeze asgiref==3.3.4 Django==3.2.1 pytz==2021.1 sqlparse==0.4.1
Не се притеснявайте, ако версиите, които получавате, са различни от моите. Ако Django продължава на версия 3.x, можете да продължите без проблем.
Стартиране на Django проект
След като инсталирате Django, е време да създадете структурата на уебсайта за съкращаване на URL адреси. Спомняте ли си какво е Django проект? Нека създадем такъв, като изпълним следната команда.
django-admin startproject config
Обяснявайки всичко за тази команда, django-admin е помощна програма от командния ред, която изпълнява всички необходими задачи за създаване на Django проект. Частта “startproject” е командата, изпълнявана от помощната програма Django-admin, а config е името на проекта, който ще създадем.
Важно е да се подчертае, че config може да бъде всяко име, което искате. Причината да използвам config като име на този проект е само заради удобството. Хубаво е да превключвате между проекти и все още да имате същата конвенция за именуване. Така че не се страхувайте да използвате други имена на проекти, когато пожелаете.
Както може би забелязвате, сега имате папка config/ и вътре има много файлове. По-късно ще видим файловата структура на проекта. Засега нека влезем в директорията на проекта и да стартираме локалния сървър.
cd config/
Най-важният файл, който ще използвате, е скриптът manage.py. Той има същата функционалност като django-admin, но основното предимство на използването му е, че ви позволява да управлявате настройките, когато изпълнявате проекта.
Сега да видим дали всичко работи правилно.
python manage.py runserver
Създаване на приложението за съкращаване на URL адреси
Време е да създадете основното приложение на проекта. Ще използвате файла manage.py, за да изпълните тази задача.
python manage.py startapp urlshortener
Това създава приложение Django с името urlshortener. Ако стартирате дърво команда, ще получите нещо подобно.
.
├── config
│ ├── asgi.py
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
├── manage.py
└── urlshortener
├── admin.py
├── apps.py
├── __init__.py
├── migrations
│ └── __init__.py
├── models.py
├── tests.py
└── views.py
Нека изясним различните файлове, създадени до този момент. “config” е името на нашия проект и е наречен така само за конвенцията. Вътре в config получавате settings.py, това е файлът, в който задавате всички настройки на вашия проект. urls.py е цялостната конфигурация на URL адресите в проекта. Той определя URL пътищата на всички приложения вътре в проекта.
Не се притеснявайте твърде много за файловете asgi.py и wsgi.py. Това са файлове, които ви позволяват да конфигурирате вашето приложение при внедряване.
Manage.py е скриптът на Python, който ви позволява да изпълнявате всички налични команди на Django-администратор.
Като погледнете вътре в urlshortener, което е името на приложението, което току-що създадохте, може да забележите, че има странна папка, наречена „migrations/“, и някои други файлове, които са от решаващо значение за логиката на всяко приложение.
apps.py е мястото, където се намира конфигурацията на приложението. Обикновено не се забърквате с него, освен че правите доста напреднали неща.
admin.py е мястото, където регистрирате вашите модели, за да ги направите видими в административния панел на Django.
models.py е най-важният. Вътре в този модул трябва да дефинирате моделите, които (неясно казано) са начинът, по който се съхраняват данните. Ще научите повече за моделите по-късно.
migrations/ е папката, в която се съхраняват миграциите на Django. По-късно ще разгледаме по-задълбочено.
tests.py е файлът, където се съхраняват тестовете. Няма да обхващаме тестването в този урок.
views.py е файлът, който съхранява изгледи. По принцип той определя как потребителят ще взаимодейства с всички аспекти на вашето приложение.
Инсталиране на приложение Django
Преди да продължите, отворете файла settings.py и променете променливата INSTALLED_APPS, като добавите приложението urlshortener.
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
# Custom apps
'urlshortener',
]
Това е рутинен процес, когато създавате приложение. Така че всеки път, когато го правите, не забравяйте да го инсталирате в настройките на проекта.
Разбиране на модела MVT
Моделът, изглед, шаблон е шаблонът за проектиране на софтуер, който разработчиците на Django използват за създаване на уеб приложения.
Базира се на 3 основни концепции. Модел (данни), изглед (взаимодействие на потребителя с данни), шаблон (как потребителите виждат данните).
Моделите са класове на Python, които дефинират всички полета и поведение на данните, които желаете да съхранявате. Обикновено всеки модел се отнася до уникална таблица в базата данни
Изгледите в техния най-прост израз са извикваеми, които приемат заявка от потребителя и генерират отговор. Между този процес възниква бизнес логиката. Знам, че „бизнес логиката“ е доста неясна концепция, така че позволете ми да обясня какво точно представлява. Бизнес логиката е начинът, по който данните се създават, съхраняват и изтриват, това е всичко.
И накрая, шаблоните са текстови документи (обикновено Html), които се показват на потребителите. Целта му е да представи данните възможно най-чисти. Django включва мини-език, наречен Django шаблонен език (DTL) което ви позволява да включите част от силата на Python в текстови документи.
Създайте модела на Shortener
След като схванахте набързо MVT модела, нека да се захванем със създаването на Django URL shortener от нулата.
Първо, нека дефинираме модела за съкращаване във файла models.py.
'''
Url shortener model
'''
from django.db import models
# Create your models here.
class Shortener(models.Model):
'''
Creates a short url based on the long one
created -> Hour and date a shortener was created
times_followed -> Times the shortened link has been followed
long_url -> The original link
short_url -> shortened link https://domain/(short_url)
'''
created = models.DateTimeField(auto_now_add=True)
times_followed = models.PositiveIntegerField(default=0)
long_url = models.URLField()
short_url = models.CharField(max_length=15, unique=True, blank=True)
class Meta:
ordering = ["-created"]
def __str__(self):
return f'{self.long_url} to {self.short_url}'
Знам. Това е доста огромен клас, в който се случват много странни неща, но не се отчайвайте. Ще разгледам всяко важно нещо стъпка по стъпка.
Обяснение на модела
Първо импортираме модула модели. Този модул съдържа цялата функционалност, от която се нуждаем, за да създадем Django модел.
Разглеждайки модела „Shortener“, първото нещо, което трябва да отбележим, е, че той разширява моделите. Всъщност всеки модел във всяко приложение на Django трябва да бъде подклас на модели.Модел клас.
След това дефинираме всички полета, които моделът ще има в базата данни. Полето „създадено“ е датата и часа, когато е създадена съкратената връзка, затова използваме DateTimeField, за да създадем този вид функционалност. Използваме аргумента auto_now_add=True, защото искаме полето да се променя само когато екземплярът е създаден.
Второто поле times_followed се отнася до пъти, когато съкратеният URL адрес е бил използван. Това е PositiveIntegerField и ние определяме нула по подразбиране. Това означава, че всеки път, когато екземпляр създаде полето times_followed, Django ще попълни това поле с 0.
От друга страна, long_url се отнася до URL адреса, въведен от потребителя. Това е URLField, защото искаме потребителят да въвежда само знаци от формата: http://yoursite.com.
Последното поле е short_url и има интересни подробности. Уточняваме, че то може да бъде дълго само 15 символа, трябва да е уникално, което означава, че в това поле не могат да има повтарящи се елементи. И накрая, посочваме, че може да се остави празно, което означава, че когато работят с формуляри, потребителите няма да трябва да пишат свой собствен код за съкращаване.
Вътрешният клас Meta ни казва как трябва да се държи класът и задаваме, че подреждането (извикване на Shortener.objects.all()) на съкращаващите обекти ще бъде дискриминирано от най-новите.
Методът __str__ казва как моделът трябва да бъде отпечатан. Така че, ако имаме обект с long_url = “https://pctechbg.net.com/” и съкратена част “123456”, и го отпечатваме.
https://pctechbg.net.com/ to 123456
Сега е време да потърсите начин да запазите кратката връзка по произволен начин.
Създаване на функционалност за съкращаване
Ще създадем 2 персонализирани функции. Първият ще генерира произволен код, а вторият ще предотврати получаването на повтарящи се произволни кодове от модела Shortener. За да направите това, създайте файл utils.py в приложението „urlshortener“.
touch utils.py
Вътре в този файл ще използваме функцията за избор от произволния вграден модул. Това улеснява задачата за избиране на произволни символи за създаване на кода.
'''
Utilities for Shortener
'''
from django.conf import settings
from random import choice
from string import ascii_letters, digits
# Try to get the value from the settings module
SIZE = getattr(settings, "MAXIMUM_URL_CHARS", 7)
AVAIABLE_CHARS = ascii_letters + digits
def create_random_code(chars=AVAIABLE_CHARS):
"""
Creates a random string with the predetermined size
"""
return "".join(
[choice(chars) for _ in range(SIZE)]
)
Както можете да видите, тази функция връща произволен низ с дължината, посочена във файла с настройки, или 7 по подразбиране. Използвате функцията getattr, за да получите променлива от модула за настройки, но без да извеждате грешка, ако променливата не е посочена.
Нека направим малко математика. Ако имаме 7 места, където може да има до 62 налични знака за всяко място, възможното пермутации са:
Така че въз основа на тези бързи изчисления, съкратената част може да бъде попълнена до 2,5 трилиона различни кода. Така че можем да забравим за излизането от произволни съкратени URL адреси.
Въпреки че може да има толкова много пермутации, има малка вероятност да се получат повтарящи се съкратени части. Това е проблем, тъй като сме настроили полето shortened_url да бъде уникално. Ето защо следната функция е толкова полезна.
def create_shortened_url(model_instance):
random_code = create_random_code()
# Gets the model class
model_class = model_instance.__class__
if model_class.objects.filter(short_url=random_code).exists():
# Run the function again
return create_shortened_url(model_instance)
return random_code
Да видим какво става тук. Функцията приема като аргумент екземпляр на модел „Shortener“. Първо, функцията генерира произволен код с помощта на create_random_code. След това получава класа на модела и проверява дали има друг обект, който има същия short_url. Ако го направи, той се изпълнява още веднъж, но ако всичко е наред, връща random_code.
По-късно ще взаимодействате с обвивката, за да разгледате отблизо тази функция.
След като създадем помощната функция, нека я използваме за създаване на произволни кодове в модела на скъсителя.
Промяна на метода за запазване
В края на класа „Shortener“ ще промените метода за запазване на модела. Методът save се извиква всеки път, когато обект се записва в базата данни, така че ще видим как да го използваме тук.
# Import the function used to create random codes
from .utils import create_shortened_url
# At the end of the Shortener model
def save(self, *args, **kwargs):
# If the short url wasn't specified
if not self.short_url:
# We pass the model instance that is being saved
self.short_url = create_shortened_url(self)
super().save(*args, **kwargs)
Методът за запазване се презаписва, което означава, че въвеждате нова функционалност към вече съществуващ родителски метод. По същество той казва на Django, че всеки път, когато обект „Shortener“ бъде записан и short_url не е посочен, той трябва да бъде попълнен с произволен код.
Течащи миграции
Сега е време да направите и стартирате миграциите на модела Shortener. За да направите това, изпълнете следните команди в основната папка на проекта.
$ python manage.py makemigrations
Migrations for 'urlshortener':
urlshortener/migrations/0001_initial.py
- Create model Shortener
$ python manage.py migrate
Operations to perform:
Apply all migrations: admin, auth, contenttypes, sessions, urlshortener
Running migrations:
......
# Apply the URL shortener migrations
Applying urlshortener.0001_initial... OK
Засега не е нужно да се притеснявате какво представляват миграциите. Само имайте предвид, че когато изпълнявате тези две команди, Django създава a база данни db.sqlite файл, въз основа на моделите, които сте дефинирали.
Нека създадем няколко обекта с обвивката на Django.
$ python manage.py shell >>> from urlshortener.models import Shortener >>> s = Shortener(long_url="https://pctechbg.net.com") >>> s.short_url '' >>> s.save() >>> s.short_url 'kdWFVIc' >>> s.long_url 'https://pctechbg.net.com' >>> print(s) https://pctechbg.net.com to kdWFVIc
Това е горе-долу начинът, по който ще работят всички съкращаващи обекти.
Писане на мнения
Както казах преди, изгледът е проста функция, която приема заявка и връща отговор. И така, нека да видим как да създадем здрав световен изглед.
Основен шаблонен отговор
Вътре във файла „urlshortener/views.py“ създайте функция home_view. аа
'''
Shortener views
'''
from django.shortcuts import render, get_object_or_404 # We will use it later
from django.http import HttpResponse
# Create your views here.
def home_view(request):
return HttpResponse("Hello world")
Той връща просто съобщение „Hello world“. По-късно ще видите как изглежда в браузъра. Сега създайте „urls.py“, там ще стоят всички URL модели на приложението.
докоснете urls.py
Добавете следния код.
'''
Urls for shortener app urlshortener/urls.py
'''
from django.urls import path
# Import the home view
from .views import home_view
appname = "shortener"
urlpatterns = [
# Home view
path("", home_view, name="home")
]
Променливата appname декларира (както подсказва името й) пространството на имената на приложението urlshortener.
Бързо обяснение, ние внасяме пътна функция, който връща елемент за включване в url шаблоните на приложението. Атрибутът name е пространството от имена на пътя, което може да бъде извикано вътре в шаблоните, ако е необходимо.
Сега нека променим общите URL адреси на проекта.
# config/urls.py
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
# Shortener Urls
path('', include('urlshortener.urls'))
]
Сега нека стартираме отново сървъра.
python manage.py runserver
Ако стартирате сървъра, ще получите просто съобщение „Hello world“. Това е така, защото включвате url шаблоните от приложението за съкращаване на URL адреси в цялостния проект.
Това е само отправна точка. Сега е време да създадете формуляр, който да позволи на потребителя сам да създава съкратени URL адреси.
Създаване на форми
В Django, a форма е прост клас, който позволява получаване на информация от потребителя.
Ще създадете файл forms.py. Това е конвенция за съхраняване на всички форми на приложението в този файл.
cd urlshortener/ touch forms.py
Вътре в този файл ще създадете клас „ShortenerForm“, който се разширява от „ModelForm“.
'''
Shortener Forms urlshortener/forms.py
'''
from django import forms
from .models import Shortener
class ShortenerForm(forms.ModelForm):
long_url = forms.URLField(widget=forms.URLInput(
attrs={"class": "form-control form-control-lg", "placeholder": "Your URL to shorten"}))
class Meta:
model = Shortener
fields = ('long_url',)
Това е моделна форма, тъй като нейната цел е да създаде моделен обект от потребителския вход. Ние също така използваме аргумента widget, който ни позволява да посочим атрибута „class“ (клас в CSS, а не в python). Това е така, защото по-късно ще стилизираме приложението с bootstrap.
Довършване на изгледите
След изграждането на формулярите е време да създадете окончателната бизнес логика на приложението.
Отидете до файла views.py в приложението за съкращаване и променете изгледа home_view. Можете да проверите на Github репо в този момент, за да добиете представа как изглежда структурата на проекта.
Има два изгледа за приложението за съкращаване на URL адреси:
Нека започнем с изгледа на дома, който е най-сложен. Ще трябва да импортирате модела и формуляра на Shortener. Все още използвате функция, тъй като искам да разберете целия поток от данни на изгледа. Освен това ще използвате пътя за шаблон (който все още не е създаден).
Домашен изглед
'''
Shortener views
'''
from django.shortcuts import render # We will use it later
from django.http import HttpResponse, Http404, HttpResponseRedirect
# Model
from .models import Shortener
# Custom form
from .forms import ShortenerForm
# Create your views here.
def home_view(request):
template="urlshortener/home.html"
context = {}
# Empty form
context['form'] = ShortenerForm()
if request.method == 'GET':
return render(request, template, context)
elif request.method == 'POST':
used_form = ShortenerForm(request.POST)
if used_form.is_valid():
shortened_object = used_form.save()
new_url = request.build_absolute_uri('/') + shortened_object.short_url
long_url = shortened_object.long_url
context['new_url'] = new_url
context['long_url'] = long_url
return render(request, template, context)
context['errors'] = used_form.errors
return render(request, template, context)
Изгледът се основава на две условия:
Един труден начин за динамично получаване на пълния URL адрес на сайта е чрез използване на метода на обект на заявка build_absolute_uri.
>>> print(request.build_absolute_uri('/'))
'https://localhost:8080/'
Като безопасен начин за обработка на грешна заявка (Потребителят не е въвел валиден URL), получаваме грешки във формуляра, предаваме ги като контекст и изобразяваме шаблона като нормален. По-късно ще видите как да внедрите показването на грешки в шаблона.
Пренасочване на изглед
redirect_url_view е малко по-опростен. Това е подробен изглед, което означава, че изгледът работи само с обект.
Тази функция приема като параметри заявката на потребителя и shortened_part от URL адреса. Не е необходимо да потвърждаваме вида на заявката, която получаваме, тъй като не работим с формуляри в този изглед.
def redirect_url_view(request, shortened_part):
try:
shortener = Shortener.objects.get(short_url=shortened_part)
shortener.times_followed += 1
shortener.save()
return HttpResponseRedirect(shortener.long_url)
except:
raise Http404('Sorry this link is broken :(')
Защитаваме изгледа с оператор try/except, в случай че съкратената част не е намерена в базата данни. Ако обектът бъде открит, той добавя 1 към полето times_followed и пренасочва с функцията HttpResponseRedirect към URL адреса на сайта, съответстващ на произволния код.
Актуализиране на URL адреси
След като създадете двата изгледа на приложението, е време да създадете крайните URL модели, като включите пътя до redirect_url_view.
Както винаги започвате с импортиране на изгледите и след това създаване на функция за път и предаване като аргументи:
- URL маршрутът
- Гледката сочи към пътеката
- Името на пътя
'''
Urls for shortener app urlshortener/urls.py
'''
from django.urls import path
# Import the home view
from .views import home_view, redirect_url_view
appname = "shortener"
urlpatterns = [
# Home view
path('', home_view, name="home"),
path('<str:shortened_part>', redirect_url_view, name="redirect"),
]
С тази настройка на URL адреса маршрутизирането на приложението изглежда така.
- localhost:8000/: Изглед на дома
- localhost:8000/URL-код: Пренасочване към дългия URL адрес
Създаване на шаблони
Почти стигнахте. Единственото нещо, което ви дели от създаването на това приложение, е потребителският интерфейс. За целта използваме Django шаблони.
Шаблоните се използват за изобразяване на чист интерфейс на потребителя на приложението. Тези файлове се създават вътре в приложението в двойна структура на папки във формата: „templates/appname“
# urlshortener directory mkdir -p templates/urlshortener/
Забележка: Двойната структура на папките и езикът на Django Template са извън обхвата на този урок, но можете да прочетете за тях в официална документация.
Основен шаблон
Django позволява наследяване на шаблони. Това означава, че можем да имаме основен шаблон и да го разширим с цел следване на принципа DRY (не се повтаряй).
cd templates/urlshortener touch base.html
Файлът base.html е конвенция и означава, че всеки друг шаблон в приложението трябва да бъде разширение на този.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta http-equiv="X-UA-Compatible" content="IE=edge" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Django Url shortener</title>
<link
href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css"
rel="stylesheet"
integrity="sha384-wEmeIV1mKuiNpC+IOBjI7aAzPcEZeedi5yW5f2yOq55WWLwNGmvvx4Um1vskeMj0"
crossorigin="anonymous"
/>
<link
rel="stylesheet"
href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css"
integrity="sha512-iBBXm8fW90+nuLcSKlbmrPcLa0OT92xO1BIsZ+ywDWZCvqsWgccV3gFoRBv0z+8dLJgyAHIhR35VZc2oM/gI1w=="
crossorigin="anonymous"
/>
</head>
<body>
{% block body %}
{% endblock body %}
<script
src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js"
integrity="sha384-p34f1UUtsS3wqzfto5wAAmdvj+osOnFyQFpp4Ua3gs/ZVWx6oOypYoCJhGGScy+8"
crossorigin="anonymous"
></script>
</body>
</html>
Ще използваме CDN за стартиране, за да направим бърз и красив интерфейс, без да се нуждаем от CSS или javascript файлове.
Ако искате да научите задълбочено за DTL таговете, можете да го направите с официални документи.
Начало шаблон
Домашният шаблон, произтичащ от файла base.html. Това означава, че този шаблон включва целия HTML от родителския файл.
{% extends 'urlshortener/base.html' %}
{% block body %}
<div class="container">
<div class="card mt-5">
<div class="card-header text-center py-3">
<h1>URL Shortner Application <i class="fas fa-link px-2"></i></h1>
</div>
<div class="px-3 py-4">
<form action="" method="POST">
{% csrf_token %}
<div class="row g-1">
<div class="col-10">{{form.long_url}}</div>
<div class="col-2">
<button class="btn btn-success btn-lg w-100" type="submit">
Shorten
</button>
</div>
</div>
</form>
</div>
</div>
{% if errors %}
<div class="alert alert-danger mt-4" role="alert">
<p>{{errors}}</p>
</div>
{% endif %}
{% if new_url %}
<div class="mx-auto text-center mt-5">
<h2 class="text-danger">Your shortened Url</h2>
<p>You can copy the Link below and share it with your friends</p>
<p class="">{{new_url}}</p>
<p><span class="text-danger">Previous URL:</span> {{long_url}}</p>
</div>
{% endif %}
</div>
{% endblock body %}
Ще обясня бързо потока от данни на този шаблон:
- Показва се формулярът Shortener. Вътре, crsf токен е зададено (съображения за сигурност) и се показва само полето за дълъг URL на формуляра. Не забравяйте, че това поле има CSS класа „form-control form-control-lg“, защото го задаваме във формуляра.
- Ако се открият грешки, покажете ги
- Ако POST операцията е успешна, се показва новият URL адрес.
Окончателно приложение
Честито! 🎉. Създадохте цялостно функционално приложение за съкращаване на URL адреси с Django.
Ето няколко екранни снимки за това как изглежда приложението.
Вземете само:
Грешка при съкращаването на URL адреса:
Успешно съкратен URL адрес:
URL пренасочен:
Какво мислите за излагането на демонстрация на това приложение за съкращаване на URL адреси на някого? Вижте как да изложите приложение Django Demo в интернет.
Предизвикателство 🔥
Ако се чувствате комфортно с вашите Django умения, защо не практикувате с предизвикателство?.
Клонирайте кода на това приложение и създайте система за удостоверяване, където само регистрирани потребители могат да съкращават своите URL адреси.
Когато сте готови, изпратете заявка за изтегляне и ме пишете Twitter за да покажете вашите постижения.
Обобщавайки
Стигнахте до края на този урок. Вярвате или не, току-що прегледахте всички основни аспекти на създаването на Django проект. Надявам се, че сте го намерили за изключително полезно.
В този урок вие:
- Научих за работния процес на създаване на приложение Django.
- Създаден проект за автобиография
- Разбра разликите и структурата на Django проектите и Django приложенията.
- Откри модела MVT.
- Основни изгледи на създадени функции
- Използва Django ORM (Object Relational Mapper) за създаване на прости модели
Това е всичко, има много за покриване с Django уеб рамкатака че поддържайте връзка за още невероятни уроци.