Let's learn Django together (part 1)
Tags: django, webdev, beginners, tutorial
Published: 2022-12-08 17:38:04

I was fascinated by Django sometime ago. Then I started to learn fronted frameworks and didn't have time for Django. Now I want to refresh my Django knowledge and share what I've learned. 

In this series of blog articles, I want to describe how to create a simple CRUD Django project similar to my diary app: https://diary-by-makneta.herokuapp.com/. I'm going to describe the process of initialising a Django project, creating a user profile, public and private diary entries. 
 
## Part 1: How to start a Django project.
 
*Content:*
1. [Step1: Install or check Python version](#step-1-install-or-check-python-version)
2. [Step 2: Make sure you have pip installed](#step-2-make-sure-you-have-pip-installed)
3. [Step 3: Create a virtual environment](#step-3-create-a-virtual-environment)
4. [Step 4: Let's install Django](#step-4-lets-install-django)
5. [Step 5: Start a Django project](#step-5-start-a-django-project)
6. [Step 6: Run the project now](#step-6-run-the-project-now)
7. [Step 7: Add small changes in website/settings.py](#step-7-add-small-changes-in-websitesettingspy)
 
 
In this part, we will be using a terminal a lot. Make sure that you know where to find the command line/terminal on your computer. If you are on Linux pressing ctrl + alt + t should open the terminal for you. Other than that, please check before starting the project.
 
If you are using a code editor like VS Code or Pycharm, you can also find the terminal there.
 
Django is a server-side web framework written in Python, so if we want to write our first project in this framework, we need to have Python installed first.
 
## Step 1: Install or check **Python** version
 
In this project, we are using Python 3.10 version. You can check it by typing in your command line:
```python --version```
 
If you type python or pip in the command line and it doesn’t work, try `python3`, `pip3`. 
 
Some Operations Systems have Python installed already, but if you are unsure or you need to upgrade to a newer version, please read this great Real Python article. It covers Python installation on different OS. https://realpython.com/installing-python/
As I said, I'm using Python 3.10 but I'm sure that 3.7, 3.8 or 3.9 will work as well.
 
## Step 2: Make sure you have **pip** installed
 
We also need `pip`. It is the standard package manager for Python. It means that we need it to install any Python library. We can quickly check the version of pip in our command line by typing:
```pip --version``` or ```pip3 –version```
If you don't have pip, please read this part of pip documentation: https://pip.pypa.io/en/stable/installation/
 
My pip version at the moment of writing this article is 22.3.1, and it's already up to date. If you would like to upgrade your `pip`, please type:
```pip install -U pip```
 
Now when we have Python and pip ready, we can start our Django project.
 
## Step 3: Create a virtual environment
 
A good practice is to start every Python project within a virtual environment. The virtual environment is like a box in which we can put our project with all libraries we need. This way we can have a few projects with a different version of Django each.
 
There are several different virtual environments available, but we are using `pipenv`.
`pipenv` is not only a virtualenv but also a package tool. In a project with `pipenv`, we will be using `pipenv` instead of `pip` to install new libraries.
 
 
First, we need to install `pipenv`.
```pip3 install --user pipenv```
 
Now let's create a folder for our project. I called my folder diary-project (you can call it as you wish) and go into this folder
```mkdir diary-project
cd diary-project```
 
We've already installed `pipenv`, and now we can use it to create a virtual environment for our project. As I wrote it before, I'm using `Python 3.10` for this project, so now, I'm telling the `pipenv` what `Python` version it should be using.
 
```pipenv --python 3.10```
 
This will create a virtualenv for this project. And we can see that there is a new file in our folder - Pipfile. It was generated automatically. It will contain the record of all libraries used in the project.
 
Now we can activate the virtual environment:
```pipenv shell```
 
There should be the name of the folder in brackets at the beginning of the line in our terminal (diary-project). If we want to stop using the virtual environment, it is enough to type `exit` in the command line or `ctrl+d`.
 
_We need to remember to activate the virtual environment every time we start working on our project. If we don't activate it, we can be surprised that some dependencies don't work._
 
Every time we install a new library/package using `pipenv install <package name>`, a new dependency will occur in the `Pipfile`. And after the first `pipenv install <package name>` a new file should be generated: `Pipfile.lock`. The `Pipfile.lock` contains the exact versions of packages as well as hashes to support more secure verification. We should not change this file manually. If missing, it can be generated with the `pipenv lock` command.
 
Both `Pipfile` and `Pipfile.lock` should be added to git. But we will take care of it in our later parts of that tutorial.
 
## Step 4: Let's install Django
 
If we want to install the current version of Django, it is enough to write:

```pipenv install django```
 
and we will have the latest Django 4.1 version (in December 2022)
 
We can also install the specific version like this:

```pipenv install "django=1.11"```

(it will install the latest of Django 1.11 version)
or

```pipenv install "django<3.0"```

(it will install the latest version lower than 3.0)
 
If we want to check what version of Django we have just installed, we should type:

```django-admin --version```

in our terminal.
 
Now we are ready to start our project.
 
## Step 5: Start a Django project
 
First, we start a project, and then we can create apps. In Django, the **project** is the entire application and all its parts. Each part of the project that can be separated from the project should be created as a separate **app**. In our case, we will create one project called `website` and two apps called: `users` and `diary`.
 
We've already seen that by installing Django, we also installed a new command: `django-admin`. Now we will use this command to create our project. Let's type in the command line:
 
```django-admin startproject website .```
 
After this command, our folders' structure should look like this (you shouldn't have README.md file at the moment because you haven't been initialising Git yet)
 

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4ul0v1zx8zex5uq8c3oo.png)
 
`website` is the name of our project and don't forget about adding the dot at the end. We do it to avoid nested folders. Now, we have two more elements in our diary-project folder. One of them is the `manage.py` file. 

From now on, every time we want to run any command connected to our project, we need to make sure we are in the folder that contains the `manage.py` file. This is our tool to execute Django-specific tasks. We will be using it while creating new apps, running the local server, or updating the database schema, and so on.
 
But we are more interested in our website folder. It contains a few files. The 2 most important for us are `urls.py` and `settings.py`.
 
In each file, we already have some code that initialises our project. `website/urls.py` file is the place where we store the URL configuration for our website. Each page on the internet needs its own address - its URL. At the moment we have an URL of the admin site of our project in `website/urls.py`, and after creating new apps, we will be adding the "address" of the app to our main `urls.py` file.
 
`settings.py` has a lot of useful stuff stored for us. While our project is growing, we will be adding new settings or changing the current ones a bit.
 
 
## Step 6: Run the project now
 
So far, we haven't written a single line of code, but we can run the local server to see our project.
Let's write in the terminal:
 
```python manage.py runserver```
 
And press enter. Our local server should be active now, and we should see some warnings in our terminal. It says that we didn't apply migrations and our project can work unproperly. From that warning, we can read that there are some built-in apps: admin, auth(for authentication), contenttype, and sessions.
But at the moment we don't want to apply any migrations. We won't be doing it until we create our Custom User model.
 
But we can also see that our development (local) server is running at http://127.0.0.1:8000/ . We can hold the `ctrl` key while pressing the link with our mouse or we can type 127.0.0.1:8000 in the browser tab to see our app running. 
 
If you look carefully at your diary-project folder, you will see a new file: `db.sqlite3`. It is a small database that is prepared for us and can be used mostly locally. SQLite is not a popular database for live applications but it’s built-in in Django to check if our database scheme is up to date.
 
 
## Step 7: Add small changes in website/settings.py
 
To start playing a bit we can do 2 things in `website.settings.py` file: 

If we want, we can change the language of the project. For example, if I would like to create a project in my native language Polish, I can go to `settings.py`: and find `LANGUAGE_CODE = 'en-us'` and change the language to **pl** `LANGUAGE_CODE = 'pl'`. If I save it, the server will restart itself, and I can see that Django's welcoming page is in Polish.
 
I can also change time zone to `TIME_ZONE = "Europe/Warsaw" `. We need to use timezone by continent and capital city.
If you need help with timezones, you can check this Wikipedia's List: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
 
 
### In the next section we are going to learn how to prepare our project for adding Git.
 
### In this part we:
1. Checked Python's version
2. Checked and upgraded pip's version
3. Installed and activated pipenv -- a virtual environment and a package manager in one tool
4. Installed Django
5. Started our Django project
6. Changed language and timezone in our project
 
### Commands used in the terminal (if python or pip doesn’t work, try python3, pip3)
1. `python --version`
2.  `pip install -U pip`
3.  `pip install --user pipenv`
4.  `mkdir diary-project`
5.  `cd diary-project`
6.  `pipenv --python 3.10`
7.  `pipenv shell`
8.  `pipenv install django`
9.  `django-admin --version`
10. `django-admin startproject website .`
11. `python manage.py runserver`