Python From Scratch: Create a Dynamic Website
How do you get started creating websites with Python? Well, you could do it all yourself and write a program that runs on a web server, accepting page requests and serving up responses in the form of HTML and other resources. However, that’s a lot of work, so why go to all the trouble when there are plenty of existing tools out there to do the job for you? These tools are called frameworks, and they’re what we’ll use today to create our website.
Python Frameworks
There are quite a few Python web frameworks, but here are some of the best:
- Django: We’re going to use this today. It has a huge set of features, but remains simple to use. The documentation is also excellent, so if you get stuck, you’ll have the easiest time solving your problem with Django.
- Flask: Flask is a lightweight web application micro-framework designed to make it easy to get started due to the many extensions that make adding new functionality easy.
- FastAPI: FastAPI is a modern, high-performance web framework for building APIs with Python 3.6+. It is also easy to use and offers autocompletion and linting, making writing code faster than with other frameworks.
- Falcon: Falcon is a minimalist web framework for building fast web APIs and app back-ends. Falcon offers a clean design that uses HTTP and the REST architectural style for building APIs quickly.
A more comprehensive list can be found on the Python website if you’re in need of additional options. Today we’re going to set Django up for development on a local machine, and then build a simple blog. We’re also going to review the process of installing it on a remote web server.
Installing Django
We’ll be performing most of our work today in the terminal. This should all work on Mac and Linux; however, if you’re running Windows, the process is somewhat different. A familiarity with the command line isn’t necessary if you’re only writing Python, although if you’re planning on using Django or running a dynamic website in general, it’s worth learning.
Terminal Tutorials
Consider reviewing these tutorials to get yourself up and running with the Terminal:
Here are the commands you need to install Django. You’ll need to install version Python 3 to get it running. First, you need to create a virtual environment with the venv module. From the Python docs:
The venv module provides support for creating lightweight “virtual environments” with their own site directories, optionally isolated from system site directories. Each virtual environment has its own Python binary (which matches the version of the binary that was used to create this environment) and can have its own independent set of installed Python packages in its site directories.
Create a project directory and a virtual environment inside the project directory.
Activate the virtual environment and create a new Django project.
django-admin.py startproject FirstBlog
The project directory looks like this:
What do each of these files do?
- __init__.py tells Python that this folder is a Python package. We learned about these in the third lesson; it allows Python to import all of the scripts in the folder as modules.
- manage.py isn’t actually part of your website; it’s a utility script that you run from the command line. It contains an array of functions for managing your site.
- settings.py contains your website’s settings. Django doesn’t use XML files for configuration; everything is Python. This file is simply a number of variables that define the setting for your site.
- urls.py is the file that maps URLs to pages. For example, it could map yourwebsite.com/about to an About Us page.
Apps
However, none of these files on their own make a functional website. For that, we need apps. Apps are where you write the code that makes your website function, but before we take a look at them, we need to understand a bit about Django’s design principles.
First, Django is an MVC framework, which stands for Model View Controller. Django refers to itself as an MTV framework, which stands for Model Template View. It’s a slightly different approach than MVC, but fundamentally, they’re quite similar. Anyhow, MVC is an architectural pattern that provides a method for structuring your projects. It separates the code that’s used to process data from the code that manages the user interface.
Secondly, Django subscribes to the DRY, or Don’t Repeat Yourself philosophy, which means that you should never be writing code that performs a certain task more than once. For example, in our blog, if we wrote a feature that picked a random article from the archive and implemented this feature on multiple pages, we wouldn’t code it again each time it was needed. We’d code it once and then use it on each page.
So how does this relate to apps? Well, apps allow you to write your website in a DRY style. Each project, like the one we have here, can contain multiple apps. Conversely, each app can be part of multiple projects. Using the example from earlier, this means that if we made another site in the future that also needed a random page feature, we wouldn’t have to write it all over again. We could simply import the app from this project.
Because of this, it’s important that each app serves one distinct purpose. If you write all the functionality of your site within one app, and then you need to use part of it again later, you have to import it all. If you were making an eCommerce website, for example, you wouldn’t want to import all the blog features. However, if you make one app for the random feature and one app for the blog publishing system, you could pick and choose the bits that you require.
This also means that within the site, the code is well organized. If you want to alter a feature, you don’t have to search through one massive file; you can instead browse to the relevant app and change it without worrying about interfering with anything else.
python3.8 manage.py startapp blog
The directory structure now looks like this:
Again, we’ve got an __init__.py file to make it a package, and three other files: models, tests, and views. We don’t need to worry about tests for now, but the other two are important. Models and Views are the M and V parts of MVC.
In models, we define our data structures.
If you’ve ever worked with PHP before, you might have used PhpMyAdmin to create your MySQL tables, and then written out your SQL queries manually in your PHP scripts. In Django, it’s much easier. We define all the data structures we need in this models file, then run a command and all the necessary databases are made for us.
When you wish to access that data, you go via these models by calling a method on them, instead of running raw queries. This is very helpful because Django can use several database programs. We’re going to use MySQL today because it’s the most powerful and is what most hosts provide, but if we needed to switch to a different database in the future, all of the code would still be valid! In other languages, if you wanted to switch to SQLite or something similar, you would need to rewrite the code that accesses your database.
In the views file, we write the code that actually generates the webpages. This ties all the other parts together. When a user types in a URL, it is sent by the urls script we saw earlier to the views script, which then gets relevant data from the models, processes it, and passes it into a template, which finally gets served up as the page the user sees. We’ll take a look at those templates shortly. They’re the easiest part—mostly HTML.
Add the blog app to the list of INSTALLED_APPS in the settings.py file.