Django is an MTV framework. Instead of MVC (Model, Views, Controller), it uses Model, Template, and View. The View is a Python function that takes a Web request and returns a Web response (in MVC, this would be a Controller). But the heart of your application is the Model.

Django model is a class that subclasses django.db.models.Model. It contains the essential fields and behaviors of your data.

Usually, each model maps to a single database table and each attribute of the model represents a database field.

In the introductory Django tutorials, you usually create a Model with few basic fields, you mess with it in the View and show it in a template.

But Model is and can do so much more. It is the single, definitive source of information about your data. That means that all the logic about your data should be located in the Model (not in View as too often can be seen).

Prerequisites

You will need the basic knowledge of Django. If you don't feel comfortable with Django yet, try this beginner-friendly tutorial.

Initial setup

Start with setting up a new Django project:

$ mkdir django_models
$ cd django_models
$ python3.9 -m venv venv
$ source venv/bin/activate
(venv)$ pip install Django
(venv)$ django-admin startproject django_models .

Create a new app:

(venv)$ django-admin startapp tutorial

and register it:

# django_models/settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'tutorial',
]

Now for the Model. We will be working on a Model for a marathon app. Our Model will be called Runner and at the beginning, it will only have 3 fields. As our business logic will progress, so will our Model.

# tutorial/models.py
from django.db import models


class Runner(models.Model):
    name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    email = models.EmailField()

For now, each runner will only have 3 fields:

• name is basic CharField with max of 50 characters (max_length is mandatory parameter for a CharField)
• last_name is basic CharField with a max of 50 characters
• email is an EmailField - that's a CharField that checks that the value is a valid email address using EmailValidator.

Our model doesn't include any additional logic.

Create and run the migrations:

(venv)$ python manage.py makemigrations
(venv)$ python manage.py migrate

If you got lost during the initial setup, I encourage you to go back to basics.

We won't be dealing with templates or views, so this concludes the basic setup. However, we need to be able to see the data somewhere, so include the Runner model in the admin panel.

# tutorial/admin.py

from django.contrib import admin
from .models import Runner


admin.site.register(Runner)

Create a superuser and run the server:

(venv)$ python manage.py createsuperuser
(venv)$ python manage.py runserver

UUID

Universally unique identifier is a 128-bit number, usually represented as 32 hexadecimal characters separated by four hyphens. The probability that a UUID will be duplicated is not zero, but it is close enough to zero to be negligible.

ID that Django uses out-of-the-box is incremented sequentially. That means that the 5th registered user has an id 5 and the 6th one has id 6. So, if I register and figure out that my id is 17, I know there were 16 people registered before me and I can try to get to their data by using their id. That makes your application very vulnerable.

That's where UUID comes in handy. UUID key is randomly generated, so it doesn't carry any information as of how many people are registered to the page or what their id might be.

Django has a special field, called UUIDField for storing UUIDs.

# tutorial/models.py

import uuid
from django.db import models

class Runner(models.Model):
    name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    email = models.EmailField()
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)

You added a new id field -- UUIDField and you made that field PRIMARY_KEY for the Runner table. UUID can be built in 5 different ways, but you'll probably want a unique and randomly generated version - version 4. You set it as a default with default=uuid.uuid4. You also don't want anyone to change that field, so you've set editable to False.

Run the migrations:

(venv)$ python manage.py makemigrations
(venv)$ python manage.py migrate

Now login with your superuser and add a test runner in the admin and see how it looks on the list of objects - that weird number in the name of the object is a UUID. If you add another runner, the string will be different.

Before adding the uuid the name of the object looked like that:

And after adding the uuid, it looks like that:

If you added any object before you've added the UUID, your database will fall apart. Before adding a new primary key, delete all the test object you added.

If you need to add a new primary key in production, things tend to get bloody - so don't do that. Think ahead and start with adding UUID at the beginning of the project.

Choices

Imagine this amazing marathon runner that last year won the Berlin marathon. Will you squish him between someone who's there just for fun and someone who decided 6 months ago that he'll run the marathon? Of course, not. Marathon start is divided into zones - the faster you are, the closer to the start line you are. If you don't have any previous results, you're in the 5th zone. And if all you do is eat, sleep and run, you're in the first zone.

It would be useful if we'd have a zone saved in our database for each of the runners. We could use an integer field, but then the user would be able to enter any number, even 100. We need to limit the entries to the 5 choices they have.

Since Django 3.0, there is a Choices class that extends Python’s Enum types with extra constraints and functionality.

Python Enumeration type

An enumeration is a set of symbolic names (members) bound to unique, constant values.

Enumeration can be iterated over. Members are immutable and can be compared. They are constants, so the names should be uppercase.

# tutorial/models.py

import uuid
from django.db import models


class Runner(models.Model):

    # this is new:
    class Zone(models.IntegerChoices):
        ZONE_1 = 1, 'Less than 3.10'
        ZONE_2 = 2, 'Less than 3.25'
        ZONE_3 = 3, 'Less than 3.45'
        ZONE_4 = 4, 'Less than 4 hours'
        ZONE_5 = 5, 'More than 4 hours'

    name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    email = models.EmailField()
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    start_zone = models.PositiveSmallIntegerField(choices=Zone.choices, default=Zone.ZONE_5, help_text="What was your best time on the marathon in last 2 years?") # this is new

We created a Choice class (an enumeration) called Zone that has 5 members. The first part (eg. ZONE_1) is the name of the enumeration member. The second part (eg. 1) is the actual value. The third part (eg. 'Less than 3.10') is a human-readable name, label. This is what you'll see in the admin.

The Choices class has two subclasses - IntegerChoices and TextChoices. Since we're only interested in the numbers of the zones, we used IntegerChoices (it doesn't matter that constant names and labels are string, you choose the type based on the values).

Now we need to connect those choices to a database field. Because we provided IntegerChoices, the field has to be one of the integer fields. Because we know there'll always be only a handful of zone possibilities, we chose PositiveSmallIntegerField. We connected the Choice class to the field with choices=Zone.choices. We selected the default value for the field and here you can see how we access one of the members (Zone.ZONE_5). The new addition is also help_text - this will show either in form or in the admin to help the user know what data they need to enter.

Run the migrations:

(venv)$ python manage.py makemigrations
(venv)$ python manage.py migrate

You should be logged in from before, open the form to add another runner, and see what changed.

Here you can see the help text you provided and the human-readable labels from the Zone class.

__str__()

If you open http://127.0.0.1:8000/admin/tutorial/runner/, you'll see the list of the runners you've added (you should at least have one), but you have no idea about the runners.

You can just see an object with some id. If you'd want to edit someone, you'd need to open each of the objects and find the one with the right name and surname. The method, that takes care of how the objects look when presented in a string (like on the list of runners) is the __str__ method.

__str__ is a Python method that returns a string representation of any object. This is what Django uses to display model instances as a plain string.

Django documentation says:

"You’ll always want to define this method; the default isn’t very helpful at all."

Let's obey Django creators and change the representation of the object to something more readable:

import uuid
from django.db import models


class Runner(models.Model):

    class Zone(models.IntegerChoices):
        ZONE_1 = 1, 'Less than 3.10'
        ZONE_2 = 2, 'Less than 3.25'
        ZONE_3 = 3, 'Less than 3.45'
        ZONE_4 = 4, 'Less than 4 hours'
        ZONE_5 = 5, 'More than 4 hours'

    name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    email = models.EmailField()
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    start_zone = models.PositiveSmallIntegerField(choices=Zone.choices, default=Zone.ZONE_5, help_text="What was your best time on the marathon in last 2 years?")

    # this is new:
    def __str__(self):
        return '%s %s' % (self.name, self.last_name)

Here you're using Python string formatting to create a string out of two variables - name and last name.

You don't need to use only variables to create the object's string representation. If you want the runners presented in a last_name, name - zone form, you can do this:

def __str__(self):
  return '%s, %s - %s' % (self.last_name, self.name, self.start_zone)

Refresh the runners' admin page, and now it's way easier to navigate through all the runners:

Why don't I have to run the migrations for this to work?

Migrations are Django's way to propagate changes you make to your models to your database schema. So you need to run the migrations only when the changes you made, impact your database. Here you only changed the string representation of an object and that doesn't impact it, so there is no need to run the migration.

Meta

As I mentioned at the beginning of this post, Django Model is more than just a class with a bunch of fields. Any additional business logic has a place in the model.

But anything that's not a field, is considered metadata and has a special place inside the model - inside the inner Meta class.

Meta class is optional, but inside it, you can change the ordering, set the verbose name, add permissions...

verbose names

I used a simple name for the class, but maybe I'd like to use a more descriptive name for the users.

Also, if you noticed, in the Django admin, your class with a singular name (Runner) is transformed to plural (Runners) - what if the plural is different than just added "s" (mouse -> mice)?

You can set both, singular and plural human-readable names.

import uuid
from django.db import models


class Runner(models.Model):

    class Zone(models.IntegerChoices):
        ZONE_1 = 1, 'Less than 3.10'
        ZONE_2 = 2, 'Less than 3.25'
        ZONE_3 = 3, 'Less than 3.45'
        ZONE_4 = 4, 'Less than 4 hours'
        ZONE_5 = 5, 'More than 4 hours'

    name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    email = models.EmailField()
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    start_zone = models.PositiveSmallIntegerField(choices=Zone.choices, default=Zone.ZONE_5, help_text="What was your best time on the marathon in last 2 years?")

    # this is new:
    class Meta:
        verbose_name = "Runner 42k"
        verbose_name_plural = "Runners 42k"

    def __str__(self):
        return '%s %s' % (self.name, self.last_name)

You've set the verbose_name and verbose_name_plural to something different in the Meta class.

If you refresh the admin, you'll see that both changed.

ordering

Inside class Meta, you can select the default ordering of the objects when the list of objects will be retained.

There's a great chance, that whatever you'll do with the Runner objects, you'll care in which zone they are. So it would be a good idea to order them by the zone.

To be able to see that they are sorted by zone, do 2 things:

1. add 4 more runners from different zones in no particular order.
2. Change the __str__ method, so it will also show the zone

import uuid
from django.db import models


class Runner(models.Model):

    class Zone(models.IntegerChoices):
        ZONE_1 = 1, 'Less than 3.10'
        ZONE_2 = 2, 'Less than 3.25'
        ZONE_3 = 3, 'Less than 3.45'
        ZONE_4 = 4, 'Less than 4 hours'
        ZONE_5 = 5, 'More than 4 hours'

    name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    email = models.EmailField()
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    start_zone = models.PositiveSmallIntegerField(choices=Zone.choices, default=Zone.ZONE_5, help_text="What was your best time on the marathon in last 2 years?")

    class Meta:
        verbose_name = "Runner 42k"
        verbose_name_plural = "Runners 42k"
        ordering = ["start_zone"] # this is new

    def __str__(self):
        return '%s %s %s' % (self.name, self.last_name, self.start_zone) # we added start_zone to the string

Before the order was set:

After ordering = ["start_zone"] was added:

It is possible to order by more than one criterion. You could sort it first by start_zone and then alphabetically by name. You could also sort it in reversed order, so the zone 5 runners are at the top (you add - inside the string before the name to reverse it).

class Meta:
  ordering = ["-start_zone", "name"]

constraints

CheckConstraint

Because long runs for youngsters are advised against, the organizer permits only runners that will be of age this calendar year. You have special constraints classes for that purpose.

You need to add a constraint that won't allow people under 18 (or with their 18th birthday coming this year) to register.

import uuid
import datetime

from django.db import models


class Runner(models.Model):

    class Zone(models.IntegerChoices):
        ZONE_1 = 1, 'Less than 3.10'
        ZONE_2 = 2, 'Less than 3.25'
        ZONE_3 = 3, 'Less than 3.45'
        ZONE_4 = 4, 'Less than 4 hours'
        ZONE_5 = 5, 'More than 4 hours'

    name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    email = models.EmailField()
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    start_zone = models.PositiveSmallIntegerField(choices=Zone.choices, default=Zone.ZONE_5, help_text="What was your best time on the marathon in last 2 years?")
    year_born = models.PositiveSmallIntegerField(default=1990) # new field added

    class Meta:
        verbose_name = "Runner 42k"
        verbose_name_plural = "Runners 42k"
        ordering = ["-start_zone", "name"]
        constraints = [ # constraints added
            models.CheckConstraint(check=models.Q(year_born__lte=datetime.date.today().year-18), name='will_be_of_age'),
        ]

    def __str__(self):
        return '%s %s %s' % (self.name, self.last_name, self.start_zone)

To be able to check if the birth year is valid, you need to add the field year_born to your Runner model.

Inside class Meta, you add constraints in a form of a list. Since you're checking if a person is old enough, you're using CheckConstraint.

CheckConstraint consist of two mandatory parts:

• check - A Q object or boolean expression that specifies the check you want the constraint to enforce.
• name - An unique name for the constraint

Q encapsulates filters as objects that can then be combined logically (using & and |), thus making it possible to use conditions in database-related operations.

The check in our case checks if the year entered in the field year_born is less or equal(year_born__lte=) to today's year minus 18 years(datetime.date.today().year-18).

Run the migrations:

(venv)$ python manage.py makemigrations
(venv)$ python manage.py migrate

Try to add a runner with year_born 2010. You'll get an integrity error:

UniqueConstraint

Let's add another constraint. Because there have been some mixups in previous runs, the organizer wants to forbid 2 persons with the same name start in the same zone.

You need to add the constraint that will prevent adding another runner with the same name, surname, and start_zone. A person with the same name can start in another zone.

import uuid
import datetime

from django.db import models


class Runner(models.Model):

    class Zone(models.IntegerChoices):
        ZONE_1 = 1, 'Less than 3.10'
        ZONE_2 = 2, 'Less than 3.25'
        ZONE_3 = 3, 'Less than 3.45'
        ZONE_4 = 4, 'Less than 4 hours'
        ZONE_5 = 5, 'More than 4 hours'

    name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    email = models.EmailField()
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    start_zone = models.PositiveSmallIntegerField(choices=Zone.choices, default=Zone.ZONE_5, help_text="What was your best time on the marathon in last 2 years?")
    year_born = models.PositiveSmallIntegerField(default=1990)

    class Meta:
        verbose_name = "Runner 42k"
        verbose_name_plural = "Runners 42k"
        ordering = ["-start_zone", "name"]
        constraints = [
            models.CheckConstraint(check=models.Q(year_born__lte=datetime.date.today().year-18), name='will_be_of_age'),
            models.UniqueConstraint(fields=['name', 'last_name', 'start_zone'], name='unique_person') # new constraint added
        ]

    def __str__(self):
        return '%s %s %s' % (self.name, self.last_name, self.start_zone)

Since you want a set of fields to be unique, you're using UniqueConstraint. You have to specify which combination of fields you want to be unique in a list (in our case fields=['name', 'last_name', 'start_zone']), and as in the previous case, you have to set a unique name for the constraint.

Try to add another person with the same name, surname, and in the same zone. This is what you'll get:

If you change any of those fields, the record will be added to DB without any problem.

Why do I get different errors?

You might have noticed that in the case of a unique constraint, there was a notice inside Django admin, and in the case of age constraint, you've been redirected to an error page.

That's because, in UniqueConstraints, you were comparing fields that were already there, so the error happened prior to saving the record to the database. But in the case of CheckConstraints, you were dealing with the database (Q() represents an SQL condition).

change the save method

There will be times when you'll want to overwrite the predefined save method. Maybe you'll want to add an additional field (eg. creation date), change the format (eg. string to date), or prevent a certain type of data.

If you want to start running in the start zone that is not the slowest (nr. 5 in our case), you have to have a previous record to prove that you can run so fast and you won't obstruct other runners. We'll add a field for entering the previous record and in the custom save method check if the field has value. If not, the runner will automatically be assigned to zone nr. 5, regardless of what they chose.

import uuid
import datetime

from django.db import models


class Runner(models.Model):

    class Zone(models.IntegerChoices):
        ZONE_1 = 1, 'Less than 3.10'
        ZONE_2 = 2, 'Less than 3.25'
        ZONE_3 = 3, 'Less than 3.45'
        ZONE_4 = 4, 'Less than 4 hours'
        ZONE_5 = 5, 'More than 4 hours'

    name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    email = models.EmailField()
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    start_zone = models.PositiveSmallIntegerField(choices=Zone.choices, default=Zone.ZONE_5, help_text="What was your best time on the marathon in last 2 years?")
    year_born = models.PositiveSmallIntegerField(default=1990)
    best_run_time = models.DurationField(default=datetime.timedelta(hours=4)) # new field added

    class Meta:
        verbose_name = "Runner 42k"
        verbose_name_plural = "Runners 42k"
        ordering = ["-start_zone", "name"]
        constraints = [
            models.CheckConstraint(check=models.Q(year_born__lte=datetime.date.today().year-18), name='will_be_of_age'),
            models.UniqueConstraint(fields=['name', 'last_name', 'start_zone'], name='unique_person')
        ]

    def __str__(self):
        return '%s %s %s' % (self.name, self.last_name, self.start_zone)

    # this is new:
    def save(self, *args, **kwargs):

        if self.best_run_time >= datetime.timedelta(hours=4):
            self.start_zone = self.Zone.ZONE_5

        super(Runner, self).save(*args, **kwargs)

You added a new field, best_run_time. Here we're also introducing a new type of field - DurationField.

DurationField is a field for storing periods of time - modeled in Python by timedelta. In Django admin, it's shown as an empty field, which is a little impractical, so we provided the default value, so you can edit it easily. We've automatically set it to 4 hours with Python's timedelta class.

You can't compare instances DurationField to instances of DateTimeField (the only exception is if using PostgreSQL).

At the bottom, you've overwritten the save method. You check if the best_run_time is more than or equal to 4 hours (datetime.timedelta(hours=4)) and if it is, you automatically set the start_zone to zone 5 (self.start_zone = self.Zone.ZONE_5).

Run the migrations:

(venv)$ python manage.py makemigrations
(venv)$ python manage.py migrate

And try to add a runner with zone selected to something less than 5. Leave the best_run_time as it is (4 hours). The runner will save without any problems, but if you check the added runner, you'll see that their start zone changed to "More than 4 hours".

Prior to saving:

After saving:

As you can see, the start zone has changed. If Charlie's best_run_time would be less than 4 hours, his selected start zone would be left as he selected it.

Conclusion

Django models are very powerful and they hide much more than you got to know here.

Nevertheless, you got to know a lot about Django models:

• less known fields
  • EmailField
  • UUIDField
  • DurationField
• how to add Choices field with the newest Django practice, using enumerators
• how to change the method for the string representation of the object
• how to work with the model's metadata:
  • verbose names
  • ordering
  • constraints
• how to overwrite the default save() method

Needless to say, some of the use cases are inappropriate for production. You can't prohibit a runner with the same name from running or automatically assign a runner who forgot to enter their best time to the slowest zone without notifying them. However, those cases are real-life enough to give you a fair idea of what you might use them for in your real-life application.

_{Image by wal_172619 from Pixabay}

You will need the basic knowledge of Django. If you don't feel comfortable with Django yet, try this beginner-friendly tutorial.

Django template filters

While tags lives between curly braces and a percent ({% tag %}), variables live between double curly braces ({{ variable }}). You can influence the variable by using filters.

Filters are functions registered to the template engine that takes a value as input and return transformed value.

IF YOU'RE CURIOUS

All the default filter functions are written in a file defaultfilters.py. This is how a wordcount filter looks like:

@register.filter(is_safe=False)
@stringfilter
def wordcount(value):
   """Return the number of words."""
   return len(value.split())

A filter is separated from a variable with a pipe {{ variable|filter }}. It is possible to use more than one filter on the variable - you just add another pipe and specify the filter ({{ variable|filter1|filter2 }}).

Initial setup

We will work on a similar project as for the Django template tags. If you did that tutorial, feel free to skip the initial setup and work on the project you created based on the Django template tags tutorial. We will work on a template with a different name, so feel free to join the initial setup from where we're changing the tutorial/urls.py. If you didn't you'll be easily able to follow, just go through the initial setup first.

Start with setting up a new Django project:

$ mkdir django_template_tutorial
$ cd django_template_tutorial
$ python3.9 -m venv venv
$ source venv/bin/activate
(venv)$ pip install Django
(venv)$ django-admin startproject django_template_filters .

Create a new app:

(venv)$ django-admin startapp tutorial
```__

and register it:
```python
# django_templates/settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'tutorial',
]

Create a model called Expense:

# tutorial/models.py
from django.db import models


class Expense(models.Model):
    datetime = models.DateTimeField()
    name = models.CharField(max_length=100)
    amount = models.FloatField()

Create and run the migrations:

(venv)$ python manage.py makemigrations
(venv)$ python manage.py migrate

If you got lost during the initial setup, I encourage you to go back to basics.

Create a folder called templates inside the tutorial folder and inside it, another folder, again called tutorial. Inside said structure, create a template called filtered_expenses.html:

django_templates
    └── tutorial
        └── templates
            └── tutorial
                └── filtered_expenses.html

Create a basic html for your filters:

<!--tutorial/templates/tutorial/filtered_expenses.html-->

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Expenses</title>
    <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">
</head>
<body>
<div class="container mt-5">
    <!-- we'll add the code for filters here when we finnish the setup-->
</div>
</body>
</html>

Everything we're going to add will be added between the <div class="container mt-5"> and </div>.

Now we need to create an url where our template will be shown.

Open django_templates/urls.py and include tutorial's urls in it:

# django_template_filters/urls.py

from django.contrib import admin
from django.urls import path, include  # this is new


urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('tutorial.urls')), # this is new
]

We haven't created tutorial/urls.py yet.

# tutorial/urls.py

from django.urls import path
from tutorial import views

urlpatterns = [
    path('', views.filter_expenses_list),
]

And the last thing is to create a view called filter_expenses_list:

# tutorial/views.py

from django.shortcuts import render
from tutorial.models import Expense


def filter_expenses_list(request):
    filter_expenses_list = Expense.objects.order_by('-datetime')

    return render(request, 'tutorial/filtered_expenses.html', {'expenses': filter_expenses_list})

The last thing to do is to add some expenses via admin so we will be able to work with something.

Register the Expense model on the admin site in the admin.py file:

# tutorial/admin.py

from django.contrib import admin
from .models import Expense

admin.site.register(Expense)

Create the superuser:

(venv)$ python manage.py createsuperuser

Start the server:

(venv)$ python manage.py runserver

Open http://127.0.0.1:8000/admin/, log in with the superuser you created, and add 5 expenses.

This was a long setup, right? Since this is an advanced tutorial, I didn't explain the setting project up. If you didn't understand something, feel free to consult the beginners tutorial.

Let's get to work

Change case

Filters allow you to change the case on the word - word can be all caps, all lowercase, you can capitalize the first letter... To see the effect of each of those filters, open your admin panel and make the expense names varied - one all lowercase, one starting with a number, one with multiple words...

Edit your html file, so it will list the expenses in a table:

<!--templates/tutorial/filtered_expenses.html-->
<table class="table">
    <tbody>
    {% for expense in expenses %}
    <tr>
        <th>{{ expense.name }}</th>
        <th>{{ expense.datetime }}</th>
        <th>{{ expense.amount }}</th>
    </tr>
    {% endfor %}
</table>

We will be adding different filters to {{ expense.name }} part.

title

title converts a string into a title case by making words start with an uppercase character and the remaining characters lowercase.

<!--templates/tutorial/filtered_expenses.html-->
<table class="table">
    <tbody>
    {% for expense in expenses %}
    <tr>
        <th>{{ expense.name|title }}</th> <!-- filter added -->
        <th>{{ expense.datetime }}</th>
        <th>{{ expense.amount }}</th>
    </tr>
    {% endfor %}
</table>

capfirst

capfirst capitalizes the first character of the value. If the first character is not a letter, this filter has no effect. Switch title for capfirst filter to the {{ expense.name }}.

<!--templates/tutorial/filtered_expenses.html-->
<table class="table">
    <tbody>
    {% for expense in expenses %}
    <tr>
        <th>{{ expense.name|capfirst }}</th> <!-- filter added -->
        <th>{{ expense.datetime }}</th>
        <th>{{ expense.amount }}</th>
    </tr>
    {% endfor %}
</table>

lower

lower converts a string into all lowercase. Switch the capfirst for a lower.

<!--templates/tutorial/filtered_expenses.html-->
<table class="table">
    <tbody>
    {% for expense in expenses %}
    <tr>
        <th>{{ expense.name|lower }}</th> <!-- filter added -->
        <th>{{ expense.datetime }}</th>
        <th>{{ expense.amount }}</th>
    </tr>
    {% endfor %}
</table>

upper

upper converts a string into all uppercase. Switch the lower for an upper.

<!--templates/tutorial/filtered_expenses.html-->
<table class="table">
    <tbody>
    {% for expense in expenses %}
    <tr>
        <th>{{ expense.name|upper }}</th> <!-- filter added -->
        <th>{{ expense.datetime }}</th>
        <th>{{ expense.amount }}</th>
    </tr>
    {% endfor %}
</table>

date

Let's say we're only interested to show the date of the expense, not the time. Edit the {{ expense.datetime }} part in the template:

<!--templates/tutorial/filtered_expenses.html-->

<!--templates/tutorial/filtered_expenses.html-->
<table class="table">
    <tbody>
    {% for expense in expenses %}
    <tr>
        <th>{{ expense.name }}</th>
        <th>{{ expense.datetime|date:"jS F Y" }}</th> <!-- filter added -->
        <th>{{ expense.amount }}</th>
    </tr>
    {% endfor %}
</table>

|date is usually followed by a colon and a desired format in the string. If not, DATE_FORMAT is used (you can set it in settings.py). In this case, we displayed the date as:

• days: jS - day of the month without the leading zero (j) + English ordinal suffix for the day of the month (S)
• month: F - the full-textual name of the month
• year: Y - 4 digits year

You can check all the possible date formats in the documentation.

In the same way, you set the time format. You can also combine it to show both.

timesince

timesince formats a date as the time since the date in the variable. Let's provide a user with a notice as to how much time has passed since their last expense.

Add this code to your html file:

<!--templates/tutorial/filtered_expenses.html-->

<div class="alert alert-success">
    It's been {{ expenses.0.datetime|timesince }} since your last expense.
</div>

timesince shows: years, months, weeks, days, hours, minutes. However, the time that passed is not always exact (the difference between 2020-02-02 and 2021-04-21 is "1 year, 2 months").

Similar to timesince is a timeuntil except that it goes from now to the date in the future.

random

random returns a random item from the given list.

How about we show the user some random saying about money to encourage them to spend money thoughtfully?

Create a list of sayings in the view and pass it to the template:

# tutorial/views.py

def filter_expenses_list(request):
    filter_expenses_list = Expense.objects.order_by('-datetime')

    # this is new
    encouragements = [
        "Opportunity is missed by most people because it is dressed in overalls and looks like work.",
        "Money is a means to get through this world, but it cannot add a day to our lives.",
        "It’s good to have money and the things that money can buy, but it’s good too to check up once in a while and make sure that you haven’t lost the things that money can’t buy.",
        "And when you start putting some rainy-day money aside, you’ll understand that it isn’t “doing nothing.” It’s letting you sleep at night."
    ]

    return render(request, 'tutorial/filtered_expenses.html', {'expenses': filter_expenses_list, "encouragements": encouragements}) # encouragaments variable is new

Add this in your html file:

<!--templates/tutorial/filtered_expenses.html-->
<div class="card mb-3">
    <h5 class="card-header">Message of encouragement</h5>
    <div class="card-body">
        <p class="card-text">{{ encouragements|random }}</p>
    </div>
</div>

You provided a list of strings and now random each time the page refreshes outputs one.

unordered_list

unordere_list creates an html list out of a python list. The list can be nested.

the list is created without the <ul> tags.

We've shown a random saying about the money. But what if someone would like to see all of the sayings? Let's create an html list of all our sayings:

<!--templates/tutorial/filtered_expenses.html-->

<ul>
    {{ encouragements|unordered_list }}
</ul>

Add expense tags

Lets's say you want your users to be able to use tags, so they can group their expenses, etc.

Open models.py and add a tags JSONfield:

# tutorial/models.py

class Expense(models.Model):
    datetime = models.DateTimeField()
    name = models.CharField(max_length=100)
    amount = models.FloatField()
    tags = models.JSONField()

Apply the migrations:

(venv)$ python manage.py makemigrations
(venv)$ python manage.py migrate

Go to the admin panel and add few tags in a JSON format.

slice

There is no limit as to how many tags your user enters. But you can't show 25 tags. You'll use slice to show just the first 2 tags.

slice returns a slice of the list, using the same syntax as Python’s list slicing.

<!--templates/tutorial/filtered_expenses.html-->

<div class="row m-4">
    {% for expense in expenses %}
    <div class="card m-2" style="max-width: 18rem;">
        <div class="card-body">
            <h5 class="card-title">{{ expense.name }}</h5>
        </div>
        <div class="card-footer bg-transparent">
            {{ expense.tags|slice:":2" }} <!-- slice -->
        </div>
    </div>
    {% endfor %}
</div>

As you can see, 2 tags are showing at most.

cut

The Food expense has no tags and it looks super ugly. You can get rid of the empty list with cut. cut removes all values of the argument from the given string.

<!--templates/tutorial/filtered_expenses.html-->

<div class="row m-4">
    {% for expense in expenses %}
    <div class="card m-2" style="max-width: 18rem;">
        <div class="card-body">
            <h5 class="card-title">{{ expense.name }}</h5>
        </div>
        <div class="card-footer bg-transparent">
            {{ expense.tags|slice:":2"|cut:"['']" }} <!-- cut added -->
        </div>
    </div>
    {% endfor %}
</div>

Now part of the string that exactly matches the argument (['']) will be removed.

This is not the only thing going on here. As you can see, you left the slice there and added the cut. You can chain filters one after the other.

length

You don't want to show a list of tags on the expense list, you just want to show how many of the tags an expense has. This can be done with length:

<!--templates/tutorial/filtered_expenses.html-->

<div class="row m-4">
    {% for expense in expenses %}
    <div class="card m-2" style="max-width: 18rem;">
        <div class="card-body">
            <h5 class="card-title">{{ expense.name }}</h5>
        </div>
        <div class="card-footer bg-transparent">
            There are {{ expense.tags|length }} tags for this expense. <!-- show just the length of the tags list -->
        </div>
    </div>
    {% endfor %}
</div>

pluralize

The first two that have 2/3 tags look good. But the last one with a single tag still has written "tags" (plural) instead of "tag"(singular). And you know what? Even that Django has covered - with pluralize.

<div class="row m-4">
    {% for expense in expenses %}
    <div class="card m-2" style="max-width: 18rem;">
        <div class="card-body">
            <h5 class="card-title">{{ expense.name }}</h5>
        </div>
        <div class="card-footer bg-transparent">
            There are {{ expense.tags|length }} tag{{ expense.tags|pluralize }} for this expense.
        </div>
    </div>
    {% endfor %}
</div>

TRICK!

You managed to cover the tag(s) problem, but there is still problem with "are" word ("There ARE 1 tag..."). You can solve that using pluralize:

<div class="card-footer bg-transparent">
  There {{ expense.tags|pluralize:"is,are" }} {{ expense.tags|length }} tag{{ expense.tags|pluralize }} for this expense.
</div>

Now "is" is used for a singular tag and "are" is used for multiple tags.

Article model

For the next couple of filters, the expenses might not be the best showcase. So let's say you add a blog to lure more clients to use your expense tracker. Open models.py and add another model, Article:

# tutorial/models.py

class Article(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()

apply the migrations:

(venv)$ python manage.py makemigrations
(venv)$ python manage.py migrate

Add the model to admin:

# tutorial/admin.py
from django.contrib import admin
from .models import Expense, Article

admin.site.register(Expense)
admin.site.register(Article)

Open the admin panel and add few articles.

If you have them, you need to show them.

Open views.py, retrieve all the articles, and pass them into the template:

from django.shortcuts import render
from tutorial.models import Expense, Article

def filter_expenses_list(request):
    filter_expenses_list = Expense.objects.order_by('-datetime')
    articles = Article.objects.all()

    encouragements = [
        "...",
    ]

    return render(request, 'tutorial/filtered_expenses.html', {'expenses': filter_expenses_list, "encouragements": encouragements, "articles": articles})

wordcount

We want to list all the articles and show how long each of them is. This can be done with the wordcount filter.

<ul>
    {% for article in articles %}
    <li>{{ article.title }}: {{ article.content|wordcount }}</li>
    {% endfor %}
</ul>

truncate

On a blog list, you usually show just a part of the text, the whole showing only in detail. Django has a few built-in possibilities to truncate the text:

• truncatechars
• truncatechars_html
• truncatewords
• truncatewords_html

Since they're so similar, we're going to use 2, but you check the other 2 in the documentation.

truncatechars

truncatechars truncates a string to the maximum of the specified number of characters. It ends with an ellipsis ("...").

<div class="row">
    {% for article in articles %}
    <div class="card" style="width: 18rem;">
        <div class="card-body">
            <h5 class="card-title">{{ article.title }}</h5>
            <p class="card-text">{{ article.content|truncatechars:150 }}</p> <!-- filter added -->
        </div>
    </div>
    {% endfor %}
</div>

Here we're listing the articles in cards. The content of the article is truncated at 150 characters.

truncatewords_html

truncatewords_html truncates a string after a certain number of words with the respect to html tags. The unclosed html tags are closed immediately after the truncation. We don't have covered the html characters in the admin (if you want to do that, you can see how it's done in this post), so we'll have to fake it.

<div class="card" style="width: 18rem;">
    <div class="card-body">
        <h5 class="card-title">{{ article.title }}</h5>
        {{ "<p class='card-text'><b>This text exists to prove</b> that html tags don't get truncated.</p>"|truncatewords_html:10 }} <!-- filter added -->
    </div>
</div>

Here we truncate a string that includes html.

As you can see, the paragraph tag closes despite the truncation:

Conclusion

Many Django filters can be useful for you. If you want to check more than you got to know in this post, you can read about them in the documentation.

As for this tutorial, you got to know:

• different ways to change cases
  • title
  • capfirst
  • lower
  • upper
• a way to stile date
• how much time has passed since some date/time with timesince
• how to produce a random item from a list
• how to create an html unordered_list from a Python list
• how to get only a part of the list with slice
• how to cut something out of a string
• how to find out the length of the value
• how to cover case, where there can be one or multiple things with pluralize
• how to do a wordcount
• multiple possibilities for truncating text:
  • truncatechars
  • truncatewords_html

_{Cover image by Daniel Mena from Pixabay}

Django templating language (Django's default out-of-the-box templating language) comes with dozens of tags that make your template powerful and allows you to do many many things. Tags provide arbitrary logic in the rendering process and they are located inside {% %} (unlike variables that are in the double curly braces - {{ }}).

Some of the tags you probably know are:

• for loop ({% for i in numbers %})
• if ({% if i > 10 %})
• extends ({% extends "base.html" %})
• block ({% block title %})

But there are less known tags that can make your life easier. To get to know some of them, we'll work on the expense tracker.

Prerequisites

You will need the basic knowledge of Django. If you don't feel comfortable with Django yet, try this beginner-friendly tutorial.

Initial setup

Start with setting up a new Django project:

$ mkdir django_template_tutorial
$ cd django_template_tutorial
$ python3.9 -m venv venv
$ source venv/bin/activate
(venv)$ pip install Django
(venv)$ django-admin startproject django_templates .

Create a new app:

(venv)$ django-admin startapp tutorial

and register it:

# django_templates/settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'tutorial',
]

Create a model called Expense:

# tutorial/models.py
from django.db import models


class Expense(models.Model):
    datetime = models.DateTimeField()
    name = models.CharField(max_length=100)
    amount = models.FloatField()

Create and run the migrations:

(venv)$ python manage.py makemigrations
(venv)$ python manage.py migrate

If you got lost during the initial setup, I encourage you to go back to basics.

Create a folder called templates inside the tutorial folder and inside it, another folder, again called tutorial. Inside this structure, create a template called expenses.html:

django_templates
    └── tutorial
        └── templates
            └── tutorial
                └── expenses.html

Confused about the directory structure? Read about Django template resolving in first part (Template chapter).

Now we need to create an url where our template will be shown.

Open django_templates/urls.py and include tutorial's urls in it:

# django_templates/urls.py

from django.contrib import admin
from django.urls import path, include  # this is new


urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('tutorial.urls')), # this is new
]

We haven't created tutorial/urls.py yet. Create the file and define just the root url:

# tutorial/urls.py

from django.urls import path
from tutorial import views

urlpatterns = [
    path('', views.expenses_list),
]

And the last thing is to create a view called expenses_list:

# tutorial/views.py

from django.shortcuts import render
from tutorial.models import Expense


def expenses_list(request):
    expenses = Expense.objects.all()

    return render(request, 'tutorial/expenses.html', {'expenses': expenses})

Run the server:

(venv)$ python manage.py runserver

If you navigate to http://127.0.0.1:8000, you'll see an empty page. Now we can finally get to our template.

Starting with the template

In the real-world application, you'd make a base template and extended it with {% extends %} tag, but we'll have only one template, so add the following:

<!--tutorial/templates/tutorial/expenses.html-->

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Expenses</title>
    <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">
</head>
<body>
    <div class="container mt-5">

    </div>
</body>
</html>

lorem

You could just start with listing the expenses, but that wouldn't look very nice, right? You should write some intro in the beginning, but what?

You'll get to that later, for now, just use the built-in lorem-ipsum generator:

<!--expenses.html-->

<div class="container">
    <div class="jumbotron">
        {% lorem 2 p random %}
    </div>
</div>

If you refresh the page, there will be 2 paragraphs from Lorem ipsum (that don't start with those words)!

lorem has 3 parameters and all three are optional:

{% lorem [count] [method] [random] %}

• number of the words/paragraphs that will be generated. It can be a number or a variable. The default value is 1.
• method will generate either:
  • words (w)
  • HTML paragraphs (p)
  • plain text paragraphs (b - this is the default value)
• random - the generated text won't start with 'Lorem ipsum'. The default is False. I think this is useful only if 'Lorem ipsum is bugging you (it does bug me and I usually add the random parameter).

You can read more on lorem in the documentation.

empty

Now let's list all the expenses we have. We don't have any expenses yet, but Django can handle that. We just need to add an {% empty %} tag inside the for loop to cover that.

<!--tutorial/templates/tutorial/expenses.html-->
<h2>All expenses</h2>

{% for expense in expenses %}
    {{ expense }}
{% empty %}
    <div class="alert alert-danger">
        There are no expenses yet.
    </div>
{% endfor %}

If you refresh the page, you'll see that there's an alert saying there are no expenses yet.

The empty tag replaces the need for an if tag checking if the array is not empty. If the array is empty, the part between the {% empty %} and {% endfor %} is shown. If the array is not empty, that part will simply get skipped.

Let's check that.

You can read more on empty in the documentation.

Adding the expenses

Stop the server with CtrlC, create the superuser and start the server again:

(venv)$ python manage.py createsuperuser
(venv)$ python manage.py runserver

Register the Expense model on the admin site in the admin.py file:

# tutorial/admin.py

from django.contrib import admin
from .models import Expense

admin.site.register(Expense)

Open http://127.0.0.1:8000/admin/, log in with the superuser you created, and add 5 expenses. Make 3 of those on the same date.

Change the expense display in expenses.html so it will show the details of each expense in a table:

<!--tutorial/templates/tutorial/expenses.html-->

<div class="container mt-5">
    <div class="jumbotron">
        {% lorem 2 p random %}
    </div>

    <h2>All expenses</h2>

    <table class="table">
        <tbody>
        {% for expense in expenses %}
            <tr>
            <th>{{ expense.datetime }}</th>
            <th>{{ expense.name }}</th>
            <th>{{ expense.amount }}</th>
            </tr>
        {% empty %}
            <div class="alert alert-danger">
                There are no expenses yet.
            </div>
        {% endfor %}
        </tbody>
    </table>
</div>

cycle

Let's say we want to add a little color to the expense table. We will alternate blue and gray with the white color. We can create rows of that color with Bootstrap classes - table-info, table-light and table-active' classes. But we need a way to alternate those classes.

This is what cycle is for.

cycle outputs one of the arguments each time the tag is encountered (usually in the for-loop, but not necessarily). When all arguments are exhausted, the cycle returns to the first argument.

<!--expenses.html-->
<h2>All expenses</h2>

<table class="table">
    <tbody>
    {% for expense in grouped_expenses %}
        <tr class="{% cycle 'table-info' 'table-light' 'table-active' 'table-light' %}"> <!-- cycle added -->
            <th>{{ expense.datetime }}</th>
            <th>{{  expense.name }}</th>
            <th>{{  expense.amount }}</th>
        </tr>
    {% empty %}
        <div class="alert alert-danger">
            There are no expenses yet.
        </div>
    {% endfor %}
    </tbody>
</table>

cycle in our case produces the Bootstrap class on each iteration. The first time will be table-info, the second time table-light, the third time table-active and so on and on, for every row in the table.

Check it out in the browser:

You can read more on cycle in the documentation.

regroup

{% regroup %} groups a list of similar objects in groups based on a common attribute. We'll use the regroup to group our expenses based on the expense tag.

Open models.py and add a tag to your Expense model.

# tutorial/models.py

from django.db import models

class Expense(models.Model):
  # this is new:
    MISCELLANEOUS = "misc"
    GROCERIES = "groc"
    HEALTH = "hlth"
    BILLS = "bill"
    EXPENSE_TAGS = [
        (MISCELLANEOUS, 'miscellaneous'),
        (GROCERIES, 'groceries'),
        (HEALTH, 'health'),
        (BILLS, 'bills'),
    ]

    datetime = models.DateTimeField()
    name = models.CharField(max_length=100)
    amount = models.FloatField()
    tag = models.CharField(max_length=20, choices=EXPENSE_TAGS, default=MISCELLANEOUS) # this is new

Check how the choices field is created.

You added a tag CharField with predefined choices that are listed in EXPENSE_TAGS. We set the default value, so every expense, including the already created ones, has a tag. Navigate to http://127.0.0.1:8000/admin/tutorial/expense/ and change tags for a few of the expenses (make sure at least three have the same tag).

You might imagine that regroup orders the input. It doesn't The input has to be ordered from the start. It just checks when the selected attribute changes. So if the input isn't organized, you will have more groups with the same attribute.

That's why we need to organize our expenses by tag for this part. Open views.py and create another object to pass to the template:

# blog/views.py

from django.shortcuts import render
from tutorial.models import Expense


def expenses_list(request):
    expenses = Expense.objects.all()
    tag_expenses = Expense.objects.order_by('tag')

    return render(request, 'tutorial/expenses.html', {'expenses': expenses, 'tag_expenses': tag_expenses })

You made the same query as for the expenses, but you ordered it by the tag attribute.

We're passing the same list of objects to the same template because this is the simplest way for a tutorial. In reality, you'd probably want to have a different page and you wouldn't query the DB twice.

Open expenses.html and add this code at the bottom of the container div:

<!--tutorial/templates/tutorial/expenses.html-->

<h2 class="mt-5">Expenses by tag</h2>

{% regroup tag_expenses by tag as grouped_expenses %}
    {% for tag in grouped_expenses %}
        <table class="table mb-5">
            <thead>
            <tr><th colspan="4">{{ tag.grouper }}</th></tr>
            </thead>
            <tbody>
            {% for expense in tag.list %}
                <tr class="{% cycle 'table-info' 'table-light' 'table-active' 'table-light' %}">
                    <td>{{ expense.datetime }}</td>
                    <td>{{ expense.name }}</td>
                    <td>{{ expense.amount }}</td>
                    <td>{{ expense.tag }}</td>
                </tr>
            {% endfor %}
            </tbody>
        </table>
    {% endfor %}

In this code, there are 3 important parts:

• {% regroup tag_expenses by tag as grouped_expenses %}
• {{ tag.grouper }}
• {% for expense in tag.list %}

{% regroup %} creates a list of group objects. A group object is a tuple-like object with two items.

The first one is a grouper. This is the item the group was grouped by (in our case, each of the tags used).

The second one is a list of all the items in this group (in our case, all the expenses with a certain tag). So now you don't access expense directly as you did in the first case, but with tag.list.

{% for expense in expenses %}

<!-- versus -->

{% for expense in tag.list %}

Everything else is either Bootstrap or something you already saw. Refresh the page.

You can read more on regroup in the documentation.

resetcycle

As you can see in the picture above, cycle doesn't start its cycle again with the new table, but continues it. So the first table starts with blue, but the next one starts with white. If you want the tables to look consistent, you need to reset the cycle each time the new table starts with {% resetcycle %}.

Add it between the ends of the outer and inner for loop:

<!--tutorial/templates/tutorial/expenses.html-->

 {% for tag in grouped_expenses %}
    <table class="table mb-5">
        <thead>
        <tr><th colspan="4">{{ tag.grouper }}</th></tr>
        </thead>
        <tbody>
        {% for expense in tag.list %}
            <tr class="{% cycle 'table-info' 'table-light' 'table-active' 'table-light' %}">
                <td>{{ expense.datetime }}</td>
                <td>{{ expense.name }}</td>
                <td>{{ expense.amount }}</td>
                <td>{{ expense.tag }}</td>
            </tr>
        {% endfor %}
        </tbody>
    </table>
    {% resetcycle %} <!-- if you want each new table to start with blue row, you have to reset the cycle -->
{% endfor %}

You can read more on resetcycle in the documentation.

comment

Maybe you're not sure what the resetcycle does? When that happens, it's usually a good idea to comment that part out and see what happens?

But if you try to comment it out with html comment, like this:

<!-- {% resetcycle %} -->

you'll see that this doesn't work.

You can comment it with the {% comment %} and you can even add a note.

{% comment "Uncomment if you want the table color cycle to reset" %}
{% resetcycle %}
{% endcomment %}

Alternatively, you can do it like this:

{# {% resetcycle %} #}

You can read more on comment in the documentation.

firstof

firstof finds the first "truthy" value and outputs it.

Python treats many values as "truthy" ones. These are non-empty strings, non-empty lists, non-empty sets, non-empty dictionaries, instances of your classes, True, integers/floats different than 0. As "falsy" it treats False, 0, None, empty lists, empty sets, empty dictionaries, empty strings, etc.

Let's say you have a dictionary of repetitive monthly expenses. If the expense has been entered (paid), the value is set either to None or 0. If not, the value is some string about the expense. You want to show the notice, alerting the user of the first expense that hasn't been entered yet (meaning it hasn't been paid yet).

Let's first create the dictionary.

Open views.py and add the dictionary:

# tutorial/views.py

from django.shortcuts import render
from tutorial.models import Expense


def expenses_list(request):
    expenses = Expense.objects.all()
    tag_expenses = Expense.objects.order_by('tag')

    # dictionary with data
    monthly_expenses = {
        "rent": 0,
        "insurance": None,
        "internet": "You haven't payed your internet bill (25.00€) yet.",
        "mobile_phone": "You haven't payed your mobile phone bill (32.50€) yet."
    }

    return render(request, 'tutorial/expenses.html', {'expenses': expenses, 'tag_expenses': tag_expenses, 'monthly_expenses': monthly_expenses}) # dictionary passed to the template

Now you can use the firstof to show the first unpaid expense somewhere at the top of the template:

<!--expenses.html-->

    {% firstof monthly_expenses.rent monthly_expenses.insurance monthly_expenses.internet monthly_expenses.mobile_phone as first_unpaid %}
    {% if first_unpaid %}
    <div class="alert alert-warning">
        You haven't paid your {{ first_unpaid }} yet.
    </div>
    {% endif %}

You've listed all the variables you want firstof to check and Django went like this (read in Django voice):

• monthly_expenses.rent -> rent is Falsy(0), I don't care about this
• monthly_expenses.insurance -> insurance is Falsy(None), I don't care about this
• monthly_expenses.internet -> this is a Truthy value, I'm outputting this
• monthly_expenses.mobile_phone -> although this is a Truthy value, I don't care about this, I already found my value
• You could provide an additional default value that would be assigned if nothing else would

Then you assigned the first truthy value to a variable named first_unpaid and you can now use it in your code. You checked if it exists and if it does, you displayed a notification about the first unpaid bill.

You can read more on firstof in the documentation.

ifchanged

{% ifchanged %} can only be used in a loop. It can either check if the content in the block changed and if it did, it displays it, or checks if one or more of the given variables changed and displays whatever is between the tags. You can also use an else clause within (the same way you would use else in a simple if).

For now we displayed unordered expenses under All expenses title. Open views.py and change expenses = Expense.objects.all() to this:

# views.py

expenses = Expense.objects.order_by('-datetime')

Everything else in views.py remains unchanged.

Now edit the table under All expenses table to include an {% ifchanged %}tags:

<!--tutorial/templates/tutorial/expenses.html-->

<h2>All expenses</h2>
<table class="table">
        <tbody>
        {% for expense in expenses %}
            {% ifchanged %}<tr><th colspan="4" class="table-dark">{{ expense.datetime|date:"F" }}</th></tr>{% endifchanged %} <!-- this is new -->
            <tr class="{% cycle 'table-info' 'table-light' 'table-active' 'table-light' %}">
                <td>{{ expense.datetime }}</td>
                <td>{{  expense.name }}</td>
                <td>{{  expense.amount }}</td>
            </tr>
        {% empty %}
            <div class="alert alert-danger">
                There are no expenses yet.
            </div>
        {% endfor %}
        </tbody>
    </table>

If the month changes, the code inside the {% ifchanged %} tags is displayed.

For this to work properly, you have to have expenses from at least two different months.

You can read more on ifchanged in the documentation.

Conclusion

In this post you learned about 8 tags:

• lorem
• empty
• cycle
• regroup
• resetcycle
• comment
• firstof
• ifchanged

You might use them often (I use {% empty %} regularly) or you might never use a tag. Don't force them, use them cautiously. However, it's good to know they're there and it's fun to feel like a magician when you produce something with just one line of code.

Those are not all the tags, you can see all of them in the documentation. Here I also presented one way of using it, there can be more than one way or they have additional parameters that we didn't explore. When your building your next Django project and trying to do something in the template, remember there might be a tag for this.

List comprehension is a concise way used instead of for-loop when you want to create a new list based on another iterable (list, tuple, dictionary, set, string, generator, ...).

You get to do this:

[do_this(element) for element in thislist if thisistrue]

instead of this:

my_list = []
for element in thislist:
    if thisistrue:
        my_list.append(do_this(element))

It's easily recognizable and more readable than (at least) 3-lines long for-loop. It's usually faster and helps you maintain your code clean and simple. It's especially neater when you want to find the common elements from two lists. You'd need two for loops for that and still only one "not-that-complicated" line for list comprehension.

The result of a list comprehension is always a new list, that's why the expression is in square brackets (there is also a dictionary comprehension, where the result is a dictionary and set comprehension where the result is a dictionary/set accordingly).

There are three parts of the comprehension inside the brackets:

• what to do (e.g. add 2 to each element)
• for what in which list (e.g. for element in the list of numbers)
• when (e.g. when the element is dividable by two)

The third part, if, can be omitted. In that case, the expression will be performed on each element of the old list and the length of the new and old list will be the same.

A very simple showcase of a list comprehension would be this:

[x+2 for x in [2, 3, 4]]

# result: [4, 5, 6]

You add 2 to each item in the list ([2+2, 3+2, 4+2]) because there is no condition.

But let's say we want the addition to be performed only on even numbers:

[x+2 for x in [2, 3, 4] if x % 2 == 0]

# result: [4, 6]

Now the addition is performed only on 2 and 4 ([2+2, 4+2]). 3 is not an even number, so it is omitted from the creation of a new list.

Those are two very simple cases, just enough for you to get an idea. In the real world, you probably won't need to add a number to a list of numbers. List comprehension in the real world is often used to perform some kind of filtering.

Filtering

When you want to create a new list with just some of the elements from the old list, you set a condition with if that will let only some of the elements pass. You can either do something with the elements that match the condition (new_x = x+2) or not (new_x = x).

Simple filtering

You know those "The hottest day this summer" news titles? Let's say you have the list of the daily temperatures from the summer and you want to get only the temperature higher than 30°C. This is how you do it:

all_temperatures = [28, 23, 38, 32, 28, 31, 29, 33]

highest_temperatures = [temperature for temperature in all_temperatures if temperature > 30]

# result: [38, 32, 31, 33]

In this case, you didn't change the elements. You just took the numbers higher than 30 from the all_temperatures list and put them into the highest_temperatures list. The all_temperatures list is unchanged.

Filtering based on the length of the element

You got a list of messages from your users. The field was required, so some of them just wrote few random letters to skip it. You want to filter out the ones with some values - the string has to be at least 10 characters long:

messages = ['Praesent orci nulla, pellentesque a consectetur id.', '/', 'zblj', 'Aliquam pellentesque diam et nibh hendrerit semper. ', 'test']
valuable_messages = [message for message in messages if len(message) > 10]

# result: ['Praesent orci nulla, pellentesque a consectetur id.', 'Aliquam pellentesque diam et nibh hendrerit semper. ']

As in the previous case, you didn't do anything with the element on the list. You just checked if it's long enough and if it is, you added it to the new list.

Filtering based on part of the tuple

Let's say you have a tuple of tuples with a name and a grade a student got for the test. Some of the students were sick, so they weren't graded and now you want to know which of the students you need to prepare another test.

grades = (('Anna', 'B'), ('May', 'A'), ('Tina', ''), ('Claire', ''), ('Beth', 'A'))

ungraded = [name for name, grade in grades if not grade]

# result: ['Tina', 'Claire']

As you can see, this is not a list, but a tuple of tuples. In the list comprehension, you declared that the first part of the inside tuple is called name and the second one is called grade (this is called tuple unpacking). Those names are of your choosing and matter only for readability purposes. For Python's sake, they could be called zblj and gn. You take the name from each tuple in the outer tuple and put it in the new list (there won't be grades listed in the new list, just names). But the element (name) goes to the new list only if the second part of the tuple (grade) is an empty string.

This is the only case we didn't create a list out of the list but out of a tuple. It doesn't matter what the source object is, only that is iterable. The outcome, however, is always a list.

Filtering and changing the element

If you need to extract numbers from the list of strings, you can check if the string contains only digits and if it does, you can convert it to an integer.

alphanumeric = ["47", "abcd", "21st", "n0w4y", "test", "55123"]
numbers = [int(string) for string in alphanumeric if string.isdigit()]

# result: [47, 55123]

On the new list are the elements from the old list that contained only digits and were transformed to integers.

Working with more than one list

Another possibility where list comprehension can be useful is when you need to somehow combine two or more lists.

Combining all the elements

You want to order mobile phones for your store. Your boss told you which color and which models to order. To make it easy for yourself, you can combine all the selected colors with all the selected models:

colors = ["red", "blue", "black"]
models = ["12", "12 mini", "12 Pro"]

order = [(model, color) for model in models for color in colors]

# result: [('12', 'red'), ('12', 'blue'), ('12', 'black'), ('12 mini', 'red'), ('12 mini', 'blue'), ('12 mini', 'black'), ('12 Pro', 'red'), ('12 Pro', 'blue'), ('12 Pro', 'black')]

Here you combined every item from the first list with every item on the second list. The length of the new list will be the product of both lengths (len(list_1) * len(list_2))

Common elements

Here's one for the Disney fans. You have a list of all the characters from Frozen. And you have a list of all the Disney princesses. Now you would like to know which Disney princesses are in the Frozen movie.

frozen = ["Anna", "Elsa", "Sven", "Olaf"]
princesses = ["Rapunzel", "Elsa", "Anna", "Ariel"]

princesses_from_frozen = [frozen_char for frozen_char in frozen for princess in princesses if frozen_char == princess]

In this case, you go through all the elements in the first list and you compare every single element with all the elements from the second list. The new list contains only the elements that appeared on both lists.

This might be the easiest to explain if you see how this would look with a for-loop:

princesses_from_frozen = []
for frozen_char in frozen: # loop through the first list
    for princess in princesses: # loop through the second list
        if frozen_char == princess: # compare the element from the first loop with the element from the second one
            princesses_from_frozen.append(frozen_char)

If you didn't previously, now you probably get the beauty of list comprehension?

Combining elements with the same position

names = ["John", "Mary", "Lea"]
surnames = ["Smith", "Wonder", "Singer"]
ages = ["22", "19", "25"]

combined = [F"{name} {surname} - {age}" for name, surname, age in zip(names, surnames, ages)]

# result: ['John Smith - 22', 'Mary Wonder - 19', 'Lea Singer - 25']

Here we need to use the Python zip function.

zip function returns a zip object, which is an iterator of tuples where the elements on the same position from different lists are paired together.

So, zip(names, surnames) would need to be turned to something readable with tuple():

print(tuple(zip(names, surnames)))

and would return:

(('John', 'Smith'), ('Mary', 'Wonder'), ('Lea', 'Singer')).

After we created a zip object, we assigned names for each element in the tuple - name, surname, age and combined all three in a string for each tuple (F"{name} {surname} - {age}"). If the lists are of different lengths, the zip will work with the shortest list. So the length of the new list will be the same as the length of the shortest list.

Using it with function

If you need to do quite a lot with the elements, you can use a function in the expression and do the logic in the function. That way, your list comprehension stays short and readable.

Convert euros to dollars

def convert_to_dol(eur):
    return round(eur * 1.19, 2)


prices = [22.30, 12.00, 0.99, 1.10]
dollar_prices = [convert_to_dol(price) for price in prices]

#result: [26.54, 14.28, 1.18, 1.31]

The above example would also work written like this:

dollar_prices = [round(price * 1.19, 2) for price in prices]

but it's not as readable, right?

Conclusion

List comprehension can be confusing at first, but it's really worth learning. You might have to do few more cases, but after a while, it will be easier to make sense of a list comprehension than of a for loop, I promise. However, don't go switching all of your for-loops with a list comprehension. It is only to be used when you need to create a new list from some other list(s).

If you're looking for some practice, here are a few ideas:

• Add a list of possible memory sizes to Combining all the elements example and create tuples combined from all three lists.
• Take the code from Common elements example, add a new list - princesses_i_like, and try to find the name that appears on all three lists (you can put in any names you want but if you want to get a result, you have to include Anna or Elsa).
• Take the code from Combining elements with the same position example and combine the data only for people older than 20.

You can find the solutions in the comments. If you think of another good use case for list comprehension, feel free to post it in the comments.

_{Image by Alexandra_Koch from Pixabay}

This is the second part of Fluent in Django series. We're going to upgrade the code we created in Part 1. You can find the finished code from the first part here.

Prerequisites

• Python
• Basics of Django (Creating a project, Model, View, Templates, Forms)
• Basic understanding of HTML, CSS, and Bootstrap
• Finished project from Part 1

If you don't want to do go through the first part, you'll need to get the project we created in Part 1 running.

How to get the poject from Part 1 running:

• clone the repo
• create a virtual enviorenment
• run pip install -r requirements.txt
• run python manage.py migrate
• run python manage.py createsuperuser
• start the server with python manage.py runserver
• go to http://127.0.0.1:8000/admin/ and create 4 books - two with a past date and two in the future.

If you're struggling with getting the project running, I encourage you to start with Part 1.

What are you going to learn

• You'll create an additional field for your form that will allow users to upload their photo when posting their opinion.
• Your BookCLub page could look a little better - that's why you're going to add some custom CSS (don't worry, the emphasis is not on CSS but on connecting it with Django).
• Why do it by yourself, if someone else has already done it - you'll use two Django packages to make your page better.
• You'll learn how to tailor Django admin to your needs.

Uploading an image

To enable users to be more personal, you'll add a possibility to upload a photo of them reading the book they're commenting on. To do this, you'll need a directory that will store the uploaded files, and connect it with Django.

Create a directory called media in the root directory. Open settings.py and add MEDIA_ROOT and MEDIA_URL.

#settings.py

MEDIA_ROOT = BASE_DIR.joinpath('media/')
MEDIA_URL = '/media/'

MEDIA_ROOT is the absolute path to the directory where the files uploaded by users will be held. MEDIA_URL is the url from where the images will be served.

To be able to serve user-uploaded media files from MEDIA_ROOT, you need to use django.conf.urls.static in your urls.py file.

# tutorial/urls.py
from django.conf.urls.static import static
from tutorial import settings

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('bookclub.urls')),
]

if settings.DEBUG:
    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

This method is inefficient and insecure and is only suitable for development. That's why we only add the static url pattern if DEBUG is set to TRUE in your settings.py. For the production, you'll need to do things differently. We'll cover pushing to production in the latter part of the series.

Django has two model fields that allow user uploads - FileField and ImageField. ImageField is a specialized version of FileField that uses Pillow to confirm that a file is an image. Pillow is an image processing library for Python, build on the unmaintained Python Imaging Library (PIL).

Install Pillow with:

(env)$ python -m pip install Pillow

Add image field to you model:

class Discussion(models.Model):
    book = models.ForeignKey('bookclub.Book', related_name='discussion', on_delete=models.CASCADE)
    author = models.ForeignKey('auth.User', related_name='records', on_delete=models.CASCADE)
    opinion = models.TextField()
    image = models.ImageField(upload_to='images', blank=True)

The image field has to contain the information where the images will get stored (media/images). We also added a blank=True, which means that the image is not a required field.

Migrate the changes:

(env)$ python manage.py makemigrations
(env)$ python manage.py migrate

You need to add an enctype attribute to the form if you want the file to be uploaded correctly:

<!--bookclub/templates/book_detail.html-->

<form method="post" enctype="multipart/form-data"> <!--this is new-->
    {% csrf_token %}
    {{ discussion_form.as_table }}
    <br>
    <button type="submit" class="btn btn-primary mt-2">Submit</button>
</form>

enctype has to be set to multipart/form-data to allow the <input>element to upload file data.

To display the image in the discussion card, you'll have to rearrange the html tags and bootstrap classes, but the basic idea stays the same:

<!--bookclub/templates/book_detail.html-->

<!--...-->
<div class="container"> <!-- this is also new -->
            <div class="row"> <!-- this is also new -->
                {% for opinion in book.discussion.all %}

                    <div class="card mb-3" style="width: 500px;">
                        <div class="row no-gutters">
                            <div class="col-md-4">
                                {% if opinion.image %}
                                    <img src="{{ opinion.image.url }}" class="card-img">
                                {% else %}
                                    <img src="http://www.jennybeaumont.com/wp-content/uploads/2015/03/placeholder.gif" class="card-img">
                                {% endif %}
                            </div>
                            <div class="col-md-8">
                                <div class="card-body">
                                    <h5 class="card-title">{{ opinion.author }}</h5>
                                    <p class="card-text">{{ opinion.opinion }}</p>
                                </div>
                            </div>
                        </div>
                    </div>
                {% empty %}
                    <div class="alert alert-secondary mt-4" role="alert">
                        There is no opinions yet for this book.
                    </div>
                {% endfor %}
            </div> <!-- this is also new -->
        </div> <!-- this is also new -->
<!--...-->

You can access the uploaded images url with {{ opinion.image.url }}. Because the image is optional (blank=True in our model), you need to check if the image exists with {% if opinion.image %}. Otherwise, you provide a placeholder.

Adding custom CSS

Things look fine but they could look much better. Since this is not a CSS tutorial, we're going to change just a few small things, just enough for you to learn how to add static files.

At the bottom of the settings.py file, you can see the static url defined: STATIC_URL = '/static/'. This tells Django the first part of url your static files can be found.

As with MEDIA_URL, this is not suitable for production.

Create a new folder named static inside the bookclub folder.

BookClub
└─── bookclub
     └─── static

Django will automatically load static files from any folder named static.

MEDIA_URL and STATIC_URL must have different values. So do MEDIA_ROOT and STATIC_ROOT.

To avoid the collision of two files with the same name inside different apps, organize it the same way as templates - inside the static folder create a folder with the same name as your app.

Create a static folder inside the bookclub app. Inside it, create another folder, named bookclub. To make it even more organized, create another folder, called css. You want to keep your code neatly organized, so you'll be able to navigate through it even when the project grows big. Inside the css folder, create a file style.css.

So this is what you have so far:

BookClub
└─── bookclub
     └─── static
         └─── bookclub
              └─── css
                   └─── style.css

Now open the style.css and add the following code:

/*bookclub.css*/

body {
    padding-bottom: 50px;
    background-color: whitesmoke;
}

.card.mb-3:nth-child(even) {
    margin-left: 20px
}

.card-img {
    position: absolute;
    top: 50%;
    transform: translateY(-50%);
}

form {
    margin-bottom: 50px;
}

This doesn't work yet - you have to connect the css file with the html. Open base.html and add the tag to load static filed and link to your css file inside the <head>.

{% load static %} <!--this is new -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>BookClub</title>
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@4.6.0/dist/css/bootstrap.min.css" integrity="sha384-B0vP5xmATw1+K9KRQjQERJvTumQW0nPEzvF6L/Z6nronJ3oUOFUFpCjEUQouq2+l" crossorigin="anonymous">
<link rel="stylesheet" href="{% static '/bookclub/css/bookclub.css' %}"> <!--this is new -->
</head>

You're using the static template tag to build the url for the given relative path ({% static '/css/bookclub.css' %}), but before using it, you need to import it ({% load static %}).

This looks a little better:

If you like CSS, feel free to add a little more pizzaz to your BookClub.

Adding Django packages

Why write it by yourself if someone else already put a lot of time to create the thing you need? There are quite some packages for Django that can make your life easier. You're going to use two of them:

• Crispy forms to make the opinion form prettier
• CKEditor so the book description and opinions can be more than just a plain text

When including Django packages, be careful. Always check on GitHub that the package is well maintained (good: updated in last 3 months / bare minimum: updated in the last year) and that users are content with it (widely used package: at least 1000 star / marginal package: 250 stars). When it comes to the packages, be like Coco Chanel - less is more.

Crispy forms

django-crispy-forms lets you control the rendering behavior of your Django forms in a very elegant and DRY way. You can make your forms prettier by adding just two simple things to the template.

Install the crispy forms in your shell:

(env)$ pip install django-crispy-forms

Add it to INSTALLED_APPS:

INSTALLED_APPS = [
    # ...
    'crispy_forms',
]

Each Django-related package you install, you need to add to INSTALLED_APPS if you want to use it.

Open book_detail.html and switch the {{ discussion_form.as_table }} part for {{ discussion_form|crispy }}. For this to work, you need to load crispy_forms_tags prior to that, so the code looks like that:

<!--book_detail.html-->
{% if discussion_open %}

{% load crispy_forms_tags %} <!-- this is new -->

<b>What are your thoughts on the book?</b>
{% if user.is_authenticated %}
    <form method="post" enctype="multipart/form-data">
        {% csrf_token %}
        {{ discussion_form|crispy }} <!-- this is changed -->
        <br>
        <button type="submit" class="btn btn-primary mt-2">Submit</button>
    </form>
{% else %}
    <div class="alert alert-warning">Only registered users are allowed to post their opinion.</div>
{% endif %}

Refresh the page and the form should look way prettier:

CKEditor

Django CKEditor is a package, that adds a WYSIWYG (What-You-See-Is-What-You-Get) editor to your admin fields and your forms.

Install the CKEditor in your shell:

(env)$ pip install django-ckeditor

Add it to INSTALLED_APPS:

INSTALLED_APPS = [
    # ...
    'crispy_forms',
    'ckeditor',
]

Now you have to copy static CKEditor required media resources into the directory given by the STATIC_ROOT setting. You don't have STATIC_ROOT set yet.

In the bottom of the settings.py, near the STATIC_URL, add

#settings.py

STATIC_ROOT = BASE_DIR.joinpath('staticfiles')

Now run the following command in your shell:

(env)$ python manage.py collectstatic

Check the folders in your project. There's an additional folder now, called staticfiles that contains all the static files that exist in your project.

Open models.py and change the description field in the Book class:

# models.py 
from ckeditor.fields import RichTextField

class Book(models.Model):
# ...
description = RichTextField()
# ...

The description is now a RichTextField. RichTextField behaves like a standard TextField, except it includes possibilities to edit the text. Don't forget to import it. Migrate the changes with python manage.py makemigrations and python manage.py migrate.

Open one of the books at http://127.0.0.1:8000/admin/bookclub/book/ and check it out.

Play around a little and edit the text. If you want the rich text to display properly, you need to add one more thing to the template:

<!--book_detail.html-->

<div class="card">
    <div class="card-body">
        {{ book.description|safe}} <!-- this is changed -->

        {% if not discussion_open %}
            <div class="alert alert-primary mt-4" role="alert">
                Read this book by: {{book.read_by}}
            </div>
        {% endif %}
    </div>
</div>

|safe Marks a string as not requiring further HTML escaping prior to output, thus making it render correctly.

Open the book you edited in the browser and now your book description has a little more style:

Users are still not able to use the CKEditor in the form.

Change the TextField() to a RichTextField() for opinion filed on the Discussion class, as you did for the Book.

# models.py 
from ckeditor.fields import RichTextField

class Discussion(models.Model):
    book = models.ForeignKey('bookclub.Book', related_name='discussion', on_delete=models.CASCADE)
    author = models.ForeignKey('auth.User', related_name='records', on_delete=models.CASCADE)
    opinion = RichTextField() # this is changed
    image = models.ImageField(upload_to='images/', blank=True)

Migrate the change with python manage.py makemigrations and python manage.py migrate. For the form to show the correct field, you just need to make sure all form media is present. Add {{ discussion_form.media }} to the book_detail.html prior to the {{ discussion_form|crispy }}.

<!--book_detail.html-->

<form method="post" enctype="multipart/form-data">
    {% csrf_token %}
    {{ discussion_form.media }} <!-- this is changed -->
    {{ discussion_form|crispy }}
    <br>
    <button type="submit" class="btn btn-primary mt-2">Submit</button>
</form>

Refresh the page and there it is.

You have to add |safe for the opinions in the book_detail.html to render correctly.

<!--book_detail.html-->
{% for opinion in book.discussion.all %}
    <div class="card mb-3" style="width: 500px;">
        <div class="row no-gutters">
            <div class="col-md-4">
                {% if opinion.image %}
                    <img src="{{ opinion.image.url }}" class="card-img">
                {% else %}
                    <img src="http://www.jennybeaumont.com/wp-content/uploads/2015/03/placeholder.gif" class="card-img">
                {% endif %}
            </div>
            <div class="col-md-8">
                <div class="card-body">
                    <h5 class="card-title">{{ opinion.author }}</h5>
                    <p class="card-text">{{ opinion.opinion|safe }}</p> <!-- this is changed -->
                </div>
            </div>
        </div>
    </div>
{% empty %}
    <div class="alert alert-secondary mt-4" role="alert">
        There is no opinions yet for this book.
    </div>
{% endfor %}

Don't forget the all_books.html. If you go to http://127.0.0.1:8000/, you'll see that text has escaped HTML. As on the book detail page, you need to add |safe - in three places.

For the showcased book:

<!--all_books.html-->
<div class="jumbotron">
    <p class="lead">What were your thoughts on the latest book?</p>
    <h3>{{previous_books.0.book}}</h3>
    <hr class="my-4">
    <p>{{previous_books.0.description|truncatewords:150|safe}}</p> <!-- |safe added -->
    <a class="btn btn-primary btn-lg" href="{% url 'book_detail' pk=previous_books.0.pk %}" role="button">See the discussion</a>
</div>

For the upcoming books:

<!--all_books.html-->
{% for upcoming_book in upcoming_books %}
    <a href="{% url 'book_detail' pk=upcoming_book.pk %}" class="list-group-item list-group-item-action">
        <div class="d-flex w-100 justify-content-between">
            <h5 class="mb-1">
                {{ upcoming_book.book }}
            </h5>
            <small class="text-muted">
                Read by: {{ upcoming_book.read_by }}
            </small>
        </div>
        <p class="mb-1">
            {{ upcoming_book.description|safe }} <!-- |safe added -->
        </p>
    </a>
{% endfor %}

And for the previous books:

<!--all_books.html-->

{% for previous_book in previous_books %}
    <a href="{% url 'book_detail' pk=previous_book.pk %}" class="list-group-item list-group-item-action">
        <div class="d-flex w-100 justify-content-between">
            <h5 class="mb-1">
                {{ previous_book.book }}
            </h5>
        </div>
        <p class="mb-1 center">
            {{ previous_book.description|safe }} <!-- |safe added -->
        </p>
    </a>
{% endfor %}

Refresh and everything look good.

Pagination

Currently, the user can only see the last 3 previous books and the first three upcoming books. But what if they want to see other books? Maybe they're looking for an idea of what to read next. Provide them with an option to browse through all the books.

Create an url 'book-list':

# bookclub/urls.py

urlpatterns = [
    path('', views.all_books, name="all_books"),
    path('book-list', views.book_list, name="book_list"), # this is new
    path('book/<int:pk>/', views.book_detail, name="book_detail"),
]

Now for the view:

# bookclub/views.py

from django.core.paginator import Paginator


def book_list(request):
    books = Book.objects.all()
    paginator = Paginator(books, 5)

    page_number = request.GET.get('page')
    page_books = paginator.get_page(page_number)

    return render(request, 'bookclub/book_list.html', {'page_books': page_books})

• You retrieve all the Book instances, as you did at the beginning of Part 1.
• You break them into groups of five with Paginator(books, 5).
• You get the info about on which page the user is from the url with request.GET.get('page').
• You retrieve the books on this page from the Paginator - paginator.get_page(page_number).
• You render only the books from that page to the template

Just dumping them in the template is quite easy, but combining them with bootstrap can look complicated. Inside the templates/bookclub directory, create a book_list.html.

<!--book_list.html-->

{% extends 'bookclub/base.html' %}

{% block title %}
    All the books
{% endblock %}}

{% block content %}
    <div class="list-group">
        {% for book in page_books %}
        <a href="{% url 'book_detail' pk=book.pk %}" class="list-group-item list-group-item-action mt-4">
            <div class="d-flex w-100 justify-content-between">
                <h5 class="mb-1">
                    {{ book.book }}
                </h5>
            </div>
            <p class="mb-1">
                {{ book.description|safe }}
            </p>
        </a>
        {% endfor %}
    </div>

    <nav class="mt-3">
        <ul class="pagination justify-content-center">
            {% for page in page_books.paginator.page_range %}
            <li class="page-item {% if page == page_books.number %}active{% endif %}">
                <a class="page-link" href="?page={{ page }}">
                    {{ page }}
                </a>
            </li>
            {% endfor %}
        </ul>
    </nav>

    <a href="{% url 'all_books'%}" class="float-right"> Home</a>
{% endblock %}

The first part is more-or-less copy-pasted from the all_books template, only you're looping through page_books.

As for the part inside the <nav>:

All the html is taken from Bootstrap. The home link takes the user to the main page.

With Django, you loop through this:

page_books.paginator.page_range

page_books is the queryset you passed from the view. The paginator in the template is not the same as the one you created in the view. They have the same name, but you could name it differently in the book_list and the paginator in the template would still work (I encourage you to try that, it's always good to see it with your own eyes). page_range is a range iterator of page numbers ([1, 2, 3, 4]), so the {{ page }} each time shows one of the numbers on the list. If you'd just like to get the total number of pages, you can use num_pages.

The only other Django thing her is:

{% if page == page_books.number %}active{% endif %}

With this, you check if the current page iteration (page) is the same as the current page you're on (page_books.number). If it is, the Bootstrap class active is added.

Add the link to this page at the bottom of the home page (inside the content block), so you can navigate to the list easily:

<!--all_books.html-->

<a href="{% url 'book_list' %}" class="btn btn-primary mt-3">Check all books</a>

Changing the admin

Admin panel can be very useful. But if you have to open the Book object (3) for the seventh time to check if that's the book you're looking for is not user-friendly. This is Django, of course, there's a better way.

Django's admin has many hooks for customization. Here you'll use only a few, but if you need something else, you have the documentation for it here.

Open admin.py and create a ModelAdmin with all the customization:

# ...
class BookAdmin(admin.ModelAdmin):
    list_display = ('book', 'read_by')
    ordering = ('-read_by',)
    search_fields = ['book']
    fields = (('book', 'read_by'), 'description')

admin.site.register(Book, BookAdmin)

# ...

So, BookAdmin is basically a 'list' of all the changes you want for your admin.

1. list_display determines which fields get displayed in the list of objects
2. ordering determines the default field to order objects by when the page loads.
3. search_fields determines which fields are searchable
4. fields are meant to make simple layout changes. In this case, we force the book and the read_by fields in the same line. This is the only change we made to the single-file admin view

Now it will be much easier to find and edit the correct book.

Conclusion

In this part, you made a huge leap from the Django basics. You added an image field, you used external packages, added custom CSS, learned how to do pagination, and changed admin to your liking. All of the things we added have a lot more to show, so I invite you to experiment a little. Play around with the packages, customize admin a little more and if you're not sure what's going on with the code, try to rename or comment out something. That way, you understand why things are the way they are in no time.

You can find the whole code from Part 2 on GitLab.

Continue with the Part 3 - COMING SOON, where we'll get the know the Django login, so your members will be able to register to the site.

A lot of information is gathered here. Don't get discouraged if you don't understand everything. This post is not meant as 'from zero to hero', it is simply meant to be a helpful guide while you navigate your new role.

Front-end vs Back-end

Right at the beginning of your journey, you'll stumble upon a decision - back-end or front-end? This decision will determine what are you going to learn and what's your job going to be.

Software is usually split into two sides: the presentation side and the data access side.

The presentation side is called front-end and the data access side is called back-end.

A person that combines both, Back-end and Front-end development is considered a full-stack developer.

Front-end

Front-end is the part of the web that the user sees. When you visit a website and you like how the page looks or when you keep scrolling through some images and images keep endlessly popping up, that's front-end work. Front-end developers also take care of different browsers and devices - it's their merit that you in Firefox and your friend on Safari see the same thing. And although the third friend doesn't see exactly the same page on their phone, they still get the essence of the page, that works well on mobile.

Front-end in its simplicity consists of three things:

• HTML: Hypertext Markup Language
• CSS: Cascading Style Sheets
• JS: JavaScript

• HTML is a markup language for documents designed to be displayed in a web browser. It's the essence of webpages. If anything else would be missing, the pages would be ugly or broken. But if HTML would be missing, there would simply be no webpage. HTML consists of HTML elements, such as a title, paragraph, link...

Markup language means that when the document is processed for display, the markup language is not shown, and is only used to format the text.

• CSS is a style sheet language used for describing the presentation of the HTML. Simply put, CSS makes HTML pretty. With it, we assign color, size, and basic behavior to the HTML element.

• JavaScript is a high-level programming language that enables interactive web pages. JavaScript is an essential part of web applications and it gets executed by the browser. It is used for getting the information from client to server, process the information it gets back, and to animate the objects on the page. As an alternative to it, TypeScript is starting to get attention.

After those basics, it gets a little more complicated. It's a waste of time to do everything by yourself. That's why you get to use libraries and frameworks. That's a bunch of neatly organized code with additional functionality that you usually get to use for free.

There are a lot of libraries for CSS (Bootstrap, Tailwind CSS...) and for JavaScript (jQuery, React...). JavaScript frameworks keep popping up and it can be hard to follow all of them. Jokes are going around the existence of so many frameworks.

Back-end

Back-end handles data storage and business logic. Usually, it is removed physically from the user. When you register to a website, your data gets sent to the server, where some things are done with your data (eg. your password is hashed, a confirmation mail is sent to you). Or when you watch movies on Netflix, this data is processed in the back-end and it returns 'Similar to watch'. That's covered by the back-end.

Unlike front-end that consists of three important parts, back-end is usually covered by only one language (as far as you're concerned). But unlike front-end, where your choices are very limited, back-end has a lot of options. Different languages are good for different things.

• JavaScript

  Yep, JavaScript can be used on both ends. It's a little confusing, but there are engines that make it possible to run JS on the server-side (eg. Node.js).

  Example (Node.js):

    http.createServer(function (req, res) {
      res.writeHead(200, {'Content-Type': 'text/plain'});
      res.end('Hello World!');
    }).listen(8080);
  

• Java (Compiled language)

  Java is a general-purpose programming language intended to let developers write code once, run anywhere. Unlike other here-mentioned languages, it has to be compiled (translated to a language that the computer understands).

    public class Main {
      public static void main(String[] args) {
        ArrayList<String> cars = new ArrayList<String>();
        cars.add("Volvo");
        cars.add("BMW");
        System.out.println(cars);
      }
    }
  

JavaScript and Java are only similar by the name. JavaScript is NOT built on Java.

• Python (Scripting language)

  Since Python emphasizes code-readability, it's a popular choice for code-newbies. It reads like bad English and it has an interesting trait - it's one of the few languages that treat indentation as significant.

  Example (Python):

    fruits = ["apple", "banana"]
  
    if "apple" in fruits:
        print("Apple is a fruit!")
  

• PHP (Scripting language)

  Php is a language that is especially suited to web development. It is widely used - among others, WordPress is built on it.

  Example (PHP):

    $cars = array("Volvo","BMW","Toyota");
    var_dump($cars);
  

Glossary

Here are some common words you may hear or read:

Library and Framework

Both libraries and frameworks are reusable code written by someone else. Their purpose is to help you solve common problems. The difference between them is, who is in control. When using a library, you are in charge of the flow of the application. When you use a framework, the framework is in charge of the flow. A framework is like moving in an already built house - you have to buy the furniture that fits and the bathroom is where it is. A library is like building a house on your own, but with friends' help - a friend that has already built their house lend you the equipment, they gave you the remainder of the tiles and the wall paint they used.

Open source

Open source is a term that refers to source code that can people freely modify, study, use and distribute. Open source is often free of charge, but this is not necessary for the code to be considered open-source.

The open source software you've probably heard of:

• Linux - (eg. Ubuntu)
• VLC Media Player
• Gimp
• Audacity

Version control

Using version control is similar to playing an arcade video-game. You know when you die and you end up in some check-point before that, not at the beginning of the game? Version control helps you to not be back at the beginning when you screw up. It is a system responsible for managing changes in your code. The most widely used software for it is Git. Git is software for tracking changes in your code. If you use Git and you screw something up, like in a video-game, you can go back to your 'git check-point'. It also makes collaboration easier, because you and your colleague won't keep driving over each-others code.

There are some kind of 'storages' where you can store your git versions. It is useful for you to keep track of your code, but also to share interesting projects you created and collaborate on projects someone else created. The most widely used ones are GitLab and GitHub.

If you open the open-source code links above - Ubuntu is hosted on GitHub and VLC on GitLab

Command line

Command-line is an abbreviation for Command-line interface (CLI). CLI is a text-based interface that developers use to communicate with computers to accomplish a wider set of tasks. CLI has a different name on different operating systems (OS):

• Windows: Command Prompt
• Mac OS, Linux: Terminal

The most basic commands are the same on all the OS, but other commands differ based on the OS you're using (Linux and macOS don't differentiate much, whether Windows commands are almost always different). Basic commands:

• change directory:
  • cd [directory] on all OS
• create a directory:
  • mkdir [name of a new directory] on all OS
• list al directories:
  • ls on Linux and Mac
  • dir on Windows
• print current local path
  • pwd for Linux and Mad
  • cd for Windows

Those are tasks that you're also able to do with the mouse, but in programming, you'll be using it to install languages, frameworks, run your code... You can also run Git commands inside your terminal.

Try to find the Terminal/Command Prompt on your computer and test some of the commands listed.

Debugging

While coding, you'll make mistakes in a form of typos, business, and coding logic. Those mistakes prevent the program you wrote to run correctly and are called bugs. The process of finding and fixing those bugs is called debugging. There are a lot of different methods and tools that assist you with it.

The terms "bug" and "debugging" are popularly attributed to Admiral Grace Hopper in the 1940s. While she was working on a Mark II computer at Harvard University, her associates discovered a moth stuck in a relay and thereby impeding operation, whereupon she remarked that they were "debugging" the system (source: Wikipedia).

Rubber-ducking

Rubber-ducking is a method of debugging code. It originates from the book The Pragmatic Programmer, where a programmer would carry around a rubber duck and debug their code by explaining the code line-by-line, to the duck. Although you think to yourself 'But no-one is doing that, right?', you'd be able to find rubber ducks on the desks of a lot of programmers. Being able to explain your code means you understand it, so it's useful if you get into the habit of doing something like that.

How to learn

1. Decide what you are trying to accomplish.

Don't do it just because it's new and everybody is learning it. Maybe you'll need it to land a new job, maybe you want to create something and that technology is the best tool for the job...

2. Watch an in-depth course.

You can find something on Udemy, Coursera, freeCodeCamp... It's important that the course thoroughly covers the basics, so you gain a good understanding of the technology.

3. Do a tutorial

You can do it during the course or after it. In my experience, there is one leap in the course, you either get it or not. If you don't, try to do the tutorial in the middle. If you do, do it after the course ends, so you consolidate your knowledge.

4. Create a simple project

Don't over-complicate it, do something you could find a tutorial for, eg. ToDo list. That way, if you get stuck, it's simple to find a solution to your problem (but do it on your own, don't just follow the tutorial).

5. Create an interesting project

That's the reason you went through all the other steps - to create something interesting and something valuable to you. That's also the step where you learn the most.

* Documentation

Each language and framework you're going to learn includes documentation. That is an online collection of materials that help you navigate through the new technologies. In it, all the methods and commands that some technologies include, are listed. There is documentation written well and there is documentation that will make you bang your head against a wall, but you will learn to understand it all. It can take some time to get used to each new documentation. When you're learning a new language, try scrolling through the basics and go back to it when you won't know how to achieve what you want with your code.

What if I get stuck

Inevitably, you'll get stuck. It's nothing wrong with that and it's nothing wrong with asking for help. You'll have to find a balance between figuring it out on your own and asking for help. You also have to learn how to ask a question. Generally, your fellow coders will be happy to help.

But: if my daughter is sitting on the couch and wants for me to bring her a glass of water, I'll be mad. If she comes to me and says: 'Mum, I tried to get myself a glass of water, but I wasn't able to reach the shelf. I tried standing on the chair, but I still couldn't reach it', I will gladly help her.

See the difference? Before asking a question, you need to research your problem, you need to be able to articulate it and suggest what you tried and didn't work.

By the rule of thumb, before asking, spend a half-hour on your problem. Make sure it's not a typo, and make sure the answer to your problem is not one of the first three hits when googling it.

Stack Overflow (SO)

Stack Overflow is a well-maintained and moderated question-and-answer site for programmers. You will be able to find the solution for most of your problems there. You don't have to be registered to use it and you'll usually get there by googling your problem. Registered users are ranked by their contribution and this defines how much they can do on the site.

• User can ask a question
• User can provide an answer to the question
• User can vote on the answer (upvote/downvote)
• User can comment on the answer
• The one who asked a question, can accept one answer

SO can be quite intimidating at the beginning, they delete the repeated questions and the question has to be well explained. Since SO is so big, the probability of you not finding a question similar to yours is very small.

When looking for an answer:

• the green checkmark means the answer was accepted as the best one. That's where probably your answer lies, but it's not necessary, so check other answers too.
• The number above it means how many people liked the answer. The higher the number, the more likely is to work.
• Under it, in smaller letters, are the comments to the answer. They're worth reading because often they provide you some additional information.
• Check the date of the answer. Languages are developing fast, frameworks even faster and the answer you found might be outdated.

Twitter

You probably know Twitter, but maybe you don't know that it has a powerful developer community. Many programmers share useful tips and tricks, a lot of them are supportive to newbies. If you want to ask someone for help, look for "DM's open" in their bio. That means you can write direct messages to them and they're usually in a helpful mood as long as you're polite and directly ask a question.

Discord

Discord is similar to old-school chat-rooms and it's gaining popularity. It's not specifically intended for programmers as SO, but it has developer communities.

Here are some that could be useful for you:

• Programmer’s Hangout
• CodeSupport
• The coding den

How to google

Googling is a big part of the coding process and it's important to know how to google.

Here are some tips:

• If you have an error, copy it to google without the specific for your code (eg. name of the file, line number of the error)
• Start your search narrow, broaden it if you didn't get what you were looking for (eg. Django settings LOGOUT_REDIRECT_URL -> Django settings )
• Remove unnecessary words ('How to', 'and', 'between', '-' ...)
• Add the technology for which you are searching (eg. Python array, Bootstrap container ...)

Tutorial hell

There are so many resources (Google, Udemy, blogs...) that enable almost anyone to learn to code by themselves. But when you're learning on your own, it can be very hard to escape tutorial hell. Doing tutorials is comfortable, they're easy to follow and you won't get stuck.

Doing a tutorial after tutorial means you won't learn more than the tutorial allows you to. Tutorials can't teach you to find creative solutions.

There's absolutely nothing wrong with starting with a tutorial. They're useful to learn the basics and you can rely on the tutorial's code to bail you out if you're stuck.

But you need to get out as soon as possible. Try altering the project you worked on for the tutorial. Try to create something similar or try to expand it. Only when you're able to do something on your own, you can call yourself a coder.

Messages from fellow coders

Your fellow developers are rooting for you. Here are some things they would like you to know:

Things will break and you may break them but the world will not end, ask questions, ask for help, read documentation, be specific with your googling...

@TyphaneyBdev

Listening and communicating skills really important to succeed as a developer. Work on your soft skills as you develop your hard skills. You're going to work with clients and as part of a team. Your soft skills will make the technical part of your job easier.

@Adriasolutions

Coding is difficult. Ignore false narratives claiming it's easy. It combines problem solving, systems thinking and logic-based creativity. Building skill requires focus, patience and persistence for years.

@curtiseinsmann

It's not always about being super technical or complex algorithm...

There is a space for developers with the ability to understand business needs, UX >design and work with other teams.

@sylvainreiter

It's more important to ask a lot of questions and ask the right questions than to know how to write code (beyond the minimum proficiency of course).

@miva2

_{Messages were originally posted on Twitter}

_{Cover image by Pexels from Pixabay}

Knowing a language will only get you so far. If you have to build everything by yourself, you'll never get things done before the deadline. After you learned a programming language, it's smart to add a framework to your arsenal. Django is the most popular full-stack framework for Python. Once you master it, the production of web applications will be fast and simple.

For your first experience with Django, let's create a BookClub application. User story goes like this. The administrator will post a book with a deadline. After the deadline passes, users will be able to discuss the book. Users will also be able to browse through old and coming-soon book selections.

Django

The Web framework for perfectionists with deadlines

Django is an open-source high-level Python framework. Django framework covers user authentication, security, content administration, and much more. One of the best traits of Django is that it comes with an out-of-the-box administrative interface.

It also majorly simplify the work with a database. Because if its Models you don't need to work directly with a database. At the same time, you can easily switch one SQL database for the other.

Django emphasizes rapid development - you can have a working, secure and admin-editable website in a matter of hours.

All-in-all, it's a framework worth knowing.

Prerequisites

• Basic knowledge of Python
• Basic knowledge of HTML
• Basic knowledge of CSS Bootstrap (you'll be using it, it's not necessary for you to understand how it works)

Setup

First, create a new directory named BookClub. Open a terminal and navigate to it. Create and activate a new Python virtual environment:

$ python3.9 -m venv env
$ source env/bin/activate

Virtual environment is a tool that helps to keep your project's dependencies separate from dependencies of other projects. It's like a little computer with its own installation of Python and other packages (Django, requests, Flask, ...) inside your computer.

After your virtual environment is active, install Django:

(env)$ pip install django

With Django installed, generate a new project:

(env)$ django-admin startproject tutorial .

django-admin.py is a command-line utility that offers a bunch of administrative tasks. In this case, with its help, you can create a project named tutorial. As you can see after you run it, it creates some files that are the core of a Django project.

. after the tutorial is an argument that tells Django to add files for a new project to the current directory instead of creating an additional and unnecessary folder for your project. You have already created a directory for the project previously and you don't need an additional one.

Next, create an app, named bookclub:

(env)$ django-admin startapp bookclub

This generates a folder named bookclub, that provides a basic structure for your app. You'll get to know most of the files in the app throughout this tutorial.

There is always only one project, but you could have multiple apps. In this tutorial, you'll need only one and it may look like overkill, but it helps you stay well-organized when working on larger projects.

Project vs. app

Understanding the importance of differing between a project and an app can be confusing at the beginning.

A project is the application you're creating. Apps are its self-sufficient parts. They don't intertwine with each other. In theory, you could copy it from one project and paste it into another without any modification.

Let's say you're creating an application for a library. You'd have a project called Library. You'd also have apps - one for managing the customers and one for managing the books. Then you'd get a job creating an online store app that you'd need to register for. You could reuse the customers app from the Library project.

Going further, open tutorial/settings.py and search for INSTALLED_APPS. Register the bookclub app at the end:

# tutorial/settings.py
INSTALLED_APPS = [
    # ...
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'bookclub',
]

INSTALLED_APPS is a list of strings designating all applications that are enabled in your project. If the application is not registered in the INSTALLED_APPS, you won't be able to use it.

Another great trait of Django it's that it rewards you very quickly and lets you know you managed to start a Django app right away. Run the local server with a command:

(env)$ python manage.py runserver

Navigate to: http://127.0.0.1:8000/

manage.py does the same things as django-admin, but it has DJANGO_SETTINGS_MODULE set to your project's settings.py file.

This is the structure you have currently:

BookClub
├── manage.py
├── tutorial
│   ├── __init__.py
│   ├── settings.py
│   ├── asgi.py
│   ├── urls.py
│   └── wsgi.py
├── bookclub
│   ├── admin.py
│   ├── apps.py
│   ├── __init__.py
│   ├── migrations
│   │   └── __init__.py
│   ├── models.py
│   ├── tests.py
│   └── views.py
├── venv

Models

As I mentioned at the beginning, in Django, you don't work directly with the database. You do that with models which are part of Django ORM (Object-relation mapper). Each model represents an entity inside your application - e.g. a book. Models are represented with classes that inherits from models.Model. This gives them the ability to store and retrieve data to/from the database. Each model has defined fields. You can enhance its behavior by adding methods to it. Each instance of your model represents a single row inside the database table. Let's see all of that in practice.

First, create a new file "bookclub/models.py" and create your first model Book:

# bookclub/models.py
from django.db import models

class Book(models.Model):
    book = models.CharField(max_length=100)
    description = models.TextField()
    read_by = models.DateField()

Book model has 3 fields. For each field, you have to provide a name and a field type. Some field types require or allow additional parameters. In this case, those fields are:

• book (title) with a maximum of 100 characters
• description is a large text field. The number of characters in it is not limited in Django, but it depends on the database you're using (eg. for MySQL the limit is 4GB).
• read_by date field

You can see all the field types here.

You created a model in models.py but it doesn't exist in the database yet. When you make a change in your models.py file, you need to communicate that to your database. You do that with migrations.

Open the migrations folder inside your bookclub directory. There you'll see only one file, __init__.py. Now run the following command:

(env)$ python manage.py makemigrations

Check the folder again and you'll be able to see another file, 0001_initial.py. This is the migration you created. If you open it, you'll see the fields you specified in there.

Now you just need to execute this migration with:

(env)$ python manage.py migrate

Migrations make sure that your database schema matches your models. They add tables, add fields, alter fields, remove tables, ...

If you're using Django 3.2, you might get a warning upon migration: Auto-created primary key used when not defining a primary key type, by default 'django.db.models.AutoField' You can ignore it for now, but you can read more about it in Django release notes.

Admin

There's an idea of books, but there's no record of any book. You can add them via the administration panel that Django provides out of the box. To be able to add new records you need to register the Book model to your admin. You can do that inside "bookclub/admin.py":

# bookclub/admin.py
from django.contrib import admin
from .models import Book

admin.site.register(Book)

Besides registering a model you also need a user to login into the administration portal. Django provides you a simple way to create a superuser - the one who can do anything. To do that, stop the server with Ctrl + C and run:

(env)$ python manage.py createsuperuser

It will prompt you for a username, email address (you don't need to provide one), and password.

Start the server again:

(env)$ python manage.py runserver

Navigate to http://127.0.0.1:8000/admin/bookclub/book/ and login with the superuser you created.

Click on Add and add 2 new books of your choosing. I added Harry Potter and Anne of Green Gables. Set one to the past date and one to the future. You'll need that further down the road.

Neat trick: Instead of Save, click Save and add another to save you some clicks. You gotta love Django right?

Show me the books!

The books are store in a database but you need to present them somehow to your users. So let's create a page that will show those books.

For each page, you need to 3 things:

• URL, where your page can be accessed
• View that is a bridge between the model and the template
• Template that will consist of some HTML and dynamic data for the books

URL

There's a file urls.py in the project's directory. But as I mentioned before, there can be only one project and multiple apps. Putting your app's URLs in the project's urls.py can quickly become a tangled mess. To prevent that, create a new file "bookclub/urls.py" and include it in the main urls.py file:

# tutorial/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('bookclub.urls')),
]

Don't forget to import include

Now open the newly created bookclub/urls.py file and write the following in it:

# bookclub/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('', views.all_books, name="all_books"),
]

Url patterns define url paths that exist inside your application. For example, /books. At this point, you're building the first page, home page, so you defined your path as '' - that translates to /. You'll be able to access this page at http://localhost:8000. The next parameter of the path is a view function. View function will receive the request from a browser and return an HTML page that will be shown in a browser. The name attribute is optional, but by assigning it, you will be able to reference it in the view methods and templates. Assigning a name also means that you can easily change the path, without the need for a change everywhere else in the project. You might have noticed that you're importing something that doesn't exist? It's view function all_books. Let's proceed and create it.

View

View function is a Python function that takes a Web request and returns a Web response. In it, you can write the logic you need to return the correct response.

By convention, the view functions are written in a file views.py.

Many of your views will return something from your models combined with a template, but not necessarily. You could also return a simple string with some HTML if you'd have some reason for it.

Open bookclub/views.py and add a all_books view to it:

# bookclub/views.py
from django.shortcuts import render


def all_books(request):
    return render(request, 'bookclub/all_books.html')

The render method is Django's method that combines the given template with the context dictionary and returns a HttpResponse with rendered text.

Template

The all_books.html file you passed to the render method doesn't exist yet. By default, Django loads templates from all templates directories inside your apps. To make templates accessible to Django you should create a new folder "bookclub/templates". If you would put all_books.html inside that folder you could call render like this return render(request, 'bookclub/all_books.html'). To avoid the name collision it's suggested to create another folder inside "bookclub/templates". This creates namespace for your templates. This way you can have index.html inside app bookclub, app users, etc.

BookClub
    └── bookclub
        └── templates
            └── bookclub
                └── all_books.html

So let's create a new folder "bookclub/templates/bookclub" and add a new file all_books.html inside:

Something

Check your application in a browser at http://localhost:8000.

If you have an error, stop the server by pressing Ctrl+C in your command line and start it again with python manage.py runserver.

Dynamic data

You need a page that will show books stored in the database. Let's improve your view function inside "bookclub/views.py":

# bookclub/views.py
from django.shortcuts import render
from bookclub.models import Book

def all_books(request):
    books = Book.objects.all()

    return render(request, 'bookclub/all_books.html', {'books': books})

You retrieved all records of the Book model with Book.objects.all() and passed it to the template as a dictionary {'books': books}.

Key books and variable name books don't need to be the same

Edit all_books.html to show books:

<!--bookclub/templates/bookclub/all_books.html-->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>BookClub</title>
</head>
<body>
{{ books }}
</body>
</html>

It's not pretty, but it's something!

Extending the template

Eventually, you'll add more templates and you don't want to keep adding the basic html tags and style/js imports to every file. To solve that problem, Django offers a template extending. Template extending makes it possible to use the same piece of HTML in more than one place. This is useful for basic HTML layout, for navigation, for imports...

You'll create a base file, that will cover the basic layout of HTML and the imports, so you won't need to do that more than once. Inside the body tags, you'll create a space for the content.

Inside the "bookclub/templates" folder, create a new file base.html:

<!--bookclub/templates/bookclub/base.html-->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>BookClub</title>
</head>
<body>
    {% block content %}
    {% endblock %}
</body>
</html>

It's the same as all_books.html with one minor change - {{ books }} is replaced with {% block content %} {% endblock %}.

Move to the all_books.html file and delete everything except the {{ books }} part:

<!--bookclub/templates/bookclub/all_books.html-->
{% extends 'bookclub/base.html' %}

{% block content %}
{{ books }}
{% endblock %}}

You don't need the rest of the code, base.html covers it.

At the top of the file, you specified which file this template is extending -> base.html. The {{ books }} variable is wrapped with a {% block content %} tag. That informs Django that this part of the template fits in the content block.

That's because you could have multiple blocks inside one template. In fact, add another block.

Variables vs. Tags

Variables are surrounded by {{ }}. They output values from the context (as set in the view).

Tags are surrounded by {% %}. They provide arbitrary logic in the rendering process. They enclose if statements and for loops.

In the base.html add a block title.

{% block title %}{% endblock %}

{% block content %}
{% endblock %}>

Now you added an additional block that can be filled, named title. You can now provide a different title for each of your pages. Add a block title to your all_books.html file.

<!--templates/bookclub/all_books.html-->
{% extends 'bookclub/base.html' %}

{% block title %}
All the books
{% endblock %}}

{% block content %}
{{ books }}
{% endblock %}}

Refresh the page and you can see the added content.

Adding Bootstrap

Plain HTML is fine for showing information but users love beautiful applications. So let's add the Bootstrap. Edit your "bookclub/templates/bookclub/base.html":

<!--bookclub/templates/bookclub/base.html-->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>BookClub</title>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
</head>
<body>
    <div class="container">
        <h1 class="mt-5 mb-5">{% block title %} {% endblock %}</h1>

        {% block content %}
        {% endblock %}
    </div>

<script src="https://code.jquery.com/jquery-3.5.1.slim.min.js" integrity="sha384-DfXdz2htPH0lsSSs5nCTpuj/zy4C+OGpamoFVy38MVBnE+IbbVYUew+OrCXaRkfj" crossorigin="anonymous"></script>
<script src="https://cdn.jsdelivr.net/npm/bootstrap@4.6.0/dist/js/bootstrap.bundle.min.js" integrity="sha384-Piv4xVNRyMGpqkS2by6br4gNJ7DXjqk09RmUpJ8jgGtD7zP9yug3goQfGII0yAns" crossorigin="anonymous"></script>
</body>
</html>

At the top of the file, you've imported Bootstrap from CDN. At the bottom, you've imported jQuery and Boortsratp's Javascript. As you can see, now everything inside the body is wrapped inside the .container and h1 has a large margin at the top and the bottom (mt-5 mb-5).

Until now, you just kind-of dumped the books data.

Let's list those books and add some style. Edit your "bookclub/templates/bookclub/all_books.html":

<!--bookclub/templates/bookclub/all_books.html-->
{% extends 'bookclub/base.html' %}

{% block title %}
All the books
{% endblock %}}

{% block content %}
<div class="list-group">
    {% for book in books %}
    <a href="#" class="list-group-item">
        <h4 class="list-group-item-heading">
            {{ book.book }}
        </h4>
        <p class="list-group-item-text">
            {{ book.description }}
        </p>
    </a>
    {% endfor %}
</div>
{% endblock %}}

That looks like a lot is going on in there, but it's not really that complicated. Instead of {{ books }}, you now display each field for each book separately. You loop through all the books one by one with {% for book in books %}. You close the forloop with {% endfor %}. You access a single field of the current book with {{ book.fieldname }}. All the divs and classes are just some HTML tags and some Bootstrap to make things look pretty.

Check the details about the list-group you used for styling the books here.

Group books

The upcoming and previous books should be displayed separately. To do that, you have to pass two separate variables to the template.

View

Change the view to provide two variables instead of one. One that will show only the upcoming books and another to show some of the previously read books. Edit your "bookclub/views.py":

from datetime import date
from django.shortcuts import render

from bookclub.models import Book


def all_books(request):
    upcoming_books = Book.objects.filter(read_by__gte=date.today()).order_by('read_by')[:3]
    previous_books = Book.objects.filter(read_by__lt=date.today()).order_by('-read_by')[:3]

    return render(request, 'bookclub/all_books.html', {'upcoming_books': upcoming_books, 'previous_books': previous_books})

There is a lot new going on in here, let's examine it in detail:

• Instead of .all() method, you're now calling .filter. This simply means you're not querying all the books, but just the ones matching the query.
• read_by is referring to the model field, __gte means greater or equal to and __lt means less than.
• In both cases, you're comparing read_by date to today's date.
• After you got the filtered results, you're sorting them by read_by date.
  • read_by sorts from today's date to the date furthest in the future ('smallest' date -> 'biggest' date)
  • -read_by sorts it the other way around - from yesterday's date to the date furthest in the past ('biggest' date -> 'smallest' date)
• [:3] shows the first 3 results.
• Instead of books, you now return values for both of your queries - upcoming_books and previous_books.

Create additional 5 books - 2 in the past, 2 in the future, and one with today's date.

Template

If you want to show both variables in the template, basic logic of it would go like this:

{% for upcoming_book in upcoming_books %}
{{ upcoming_book.book }}
{{ upcoming_book.read_by }}
{{ upcoming_book.description }}
{% endfor %}

{% for previous_book in previous_books %}
{{ previous_book.book }}
{{ previous_book.read_by }}
{{ previous_book.description }}
{% endfor %}

But that would produce a very ugly result.

Resort to Bootstrap to make it pretty.

Besides the list group for the books, use tabs to enable the user to switch between previous and upcoming books effortlessly. Edit your "bookclub/templates/bookclub/all_books.html":

<!--templates/bookclub/all_books.html-->
{% extends 'bookclub/base.html' %}

{% block title %}
All the books
{% endblock %}}

{% block content %}
<ul class="nav nav-tabs mb-3" id="allBooks" role="tablist">
    <li class="nav-item" role="presentation">
        <a class="nav-link active" id="home-tab" data-toggle="tab" href="#upcoming" role="tab" aria-controls="upcoming" aria-selected="true">Upcoming Books</a>
    </li>
    <li class="nav-item" role="presentation">
        <a class="nav-link" id="profile-tab" data-toggle="tab" href="#previous" role="tab" aria-controls="previous" aria-selected="false">Previous Books</a>
    </li>
</ul>
<div class="tab-content" id="allBooksContent">
    <div class="tab-pane fade show active" id="upcoming" role="tabpanel" aria-labelledby="upcoming-tab">
        <div class="list-group">
            {% for upcoming_book in upcoming_books %}
            <a href="#" class="list-group-item list-group-item-action">
                <div class="d-flex w-100 justify-content-between">
                    <h5 class="mb-1">
                        {{ upcoming_book.book }}
                    </h5>
                    <small class="text-muted">
                        Read by: {{ upcoming_book.read_by }}
                    </small>
                </div>
                <p class="mb-1">
                    {{ upcoming_book.description }}
                </p>
            </a>
            {% endfor %}
        </div>
    </div>
    <div class="tab-pane fade" id="previous" role="tabpanel" aria-labelledby="previous-tab">
        <div class="list-group">
            {% for previous_book in previous_books %}
            <a href="#" class="list-group-item list-group-item-action">
                <div class="d-flex w-100 justify-content-between">
                    <h5 class="mb-1">
                        {{ previous_book.book }}
                    </h5>
                </div>
                <p class="mb-1">
                    {{ previous_book.description }}
                </p>
            </a>
            {% endfor %}
        </div>
    </div>

</div>
{% endblock %}}

This is much prettier, right?

As you can see, today's book is showing in the upcoming books tab, because you used __gte in the query. If you'd use __gt, the book with today's date would not show. If you've created 4 upcoming books (3 with future dates and today's one), you can also see that the last one is not showing. That's because you're showing only the 3 books closest to today's date.

Single book view

The business model predicts that users will be able to comment on the book. This means you need to have a page for a single book.

First, add the url in "bookclub/urls.py":

# bookclub/urls.py
# imports here

urlpatterns = [
    path('', views.all_books, name="all_books"),
    path('book/<int:pk>/', views.book_detail, name="book_detail"),
]

Every single book will have an url like this http://127.0.0.1:8000/book/1/. The <int:pk> part means that in this part of url an integer is expected. With Django's help, you will be able to extract it and match it with a book's id in the view. Add a new view for book details to "bookclub/views.py":

# bookclub/views.py

from datetime import date
from django.shortcuts import render, get_object_or_404
from bookclub.models import Book

# all_books view here

def book_detail(request, pk):
    book = get_object_or_404(Book, pk=pk)

    return render(request, 'bookclub/book_detail.html', {'book': book})

get_object_or_404 calls a get() method on the given Model and it raises 404 error when an expected object is not found. The pk key from the url is passed to the view as a parameter and you pass it to the get_object_or_404, so it returns the book with the correct id.

pk is the abbreviation for primary key of the object. In this case, it's an ID of the row in a database.

You pass the book you get back in the context dictionary to a template book_detail.html that you have yet to create.

Add a new file named book_detail.html inside "bookclub/templates/bookclub" folder:

<!--bookclub/templates/bookclub/book_detail.html-->

{% extends 'bookclub/base.html' %}

{% block title %}
{{ book.book }}
{% endblock %}}

{% block content %}
<div class="card">
    <div class="card-body">
        {{ book.description}}
    </div>
</div>
{% endblock %}

Part of this template is very similar to the previous one:

• you extended the base.html
• you have a block title and block content
• you have divs with some Bootstrap classes

The difference is that you didn't hardcode the title of the page, but provided the title of a book in it. In the body of the card, the book description is displayed.

Link between the pages

If you navigate to http://127.0.0.1:8000/ and you try to click on the book, you'll find out that although the single page for the book exists, you can't navigate there via links. To add that possibility, open all_books.html. Because you loop through books two times, you need to change the HTML in the two places.

{% block content %}

<ul class="nav nav-tabs mb-3" id="allBooks" role="tablist">
    <li class="nav-item" role="presentation">
        <a class="nav-link active" id="home-tab" data-toggle="tab" href="#upcoming" role="tab" aria-controls="upcoming" aria-selected="true">Upcoming Books</a>
    </li>
    <li class="nav-item" role="presentation">
        <a class="nav-link" id="profile-tab" data-toggle="tab" href="#previous" role="tab" aria-controls="previous" aria-selected="false">Previous Books</a>
    </li>
</ul>
<div class="tab-content" id="allBooksContent">
    <div class="tab-pane fade show active" id="upcoming" role="tabpanel" aria-labelledby="upcoming-tab">
        <div class="list-group">
            {% for upcoming_book in upcoming_books %}
            <a href="{% url 'book_detail' pk=upcoming_book.pk %}" class="list-group-item list-group-item-action"> <!--          this is new-->
                <div class="d-flex w-100 justify-content-between">
                    <h5 class="mb-1">
                        {{ upcoming_book.book }}
                    </h5>
                    <small class="text-muted">
                        Read by: {{ upcoming_book.read_by }}
                    </small>
                </div>
                <p class="mb-1">
                    {{ upcoming_book.description }}
                </p>
            </a>
            {% endfor %}
        </div>
    </div>
    <div class="tab-pane fade" id="previous" role="tabpanel" aria-labelledby="previous-tab">
        <div class="list-group">
            {% for previous_book in previous_books %}
            <a href="{% url 'book_detail' pk=previous_book.pk %}" class="list-group-item list-group-item-action"> <!--          this is new-->
                <div class="d-flex w-100 justify-content-between">
                    <h5 class="mb-1">
                        {{ previous_book.book }}
                    </h5>
                </div>
                <p class="mb-1">
                    {{ previous_book.description }}
                </p>
            </a>
            {% endfor %}
        </div>
    </div>

</div>
{% endblock %}}

With url, you're ordering Django to create an url. Url will be composed as follows:

• book_detail refers to the name you gave to your URL pattern inside the urls.py (book/<int:pk>/)
• the private key (upcoming_book.pk) for the current book is passed as a parameter, so the <int:pk> will be correctly filled.

Refresh the http://127.0.0.1:8000/ page. Now if you click on one of the books, you should get to the single page for said book.

But you can't navigate back.

Edit your bookclub/templates/bookclub/book_detail.html to add a back button:

<!--book_detail.html-->
<div class="card">
    <div class="card-body">
        {{ book.description}}

        {% if not discussion_open %}
        <div class="alert alert-primary mt-4" role="alert">
            Read this book by: {{book.read_by}}
        </div>
        {% endif %}
    </div>
</div>
<a href="{% url 'all_books'%}" class="float-right">Back to all books</a> <!--          this is new-->

As you can see, the url creation is very similar to the previous one, the only difference is that you didn't need to provide a pk parameter. Now you can navigate between a single book and the list.

Add some logic to the view

At this point, you just got some data from the Book model and you passed it to the template. You can do more than that in a view - you can do something with the data you retrieved and pass that to the template.

Just seeing a book description is not very useful. You have a Wikipedia page for that. You want people to be able to discuss the book, but only if the deadline hasn't already passed. This means the template will change a little, based on the date of the deadline - upcoming books will show the deadline and previous books will have the discussion open.

To know what to show for the book in question, you need to pass some sort of a flag from the book_detail view inside "bookclub/views.py":

# bookclub/views.py
# all_ books view and other imports

from django.shortcuts import render, get_object_or_404

def book_detail(request, pk):
    book = get_object_or_404(Book, pk=pk)
    discussion_open = False

    if book.read_by <= date.today():
        discussion_open = True

    return render(request, 'bookclub/book_detail.html', {'book': book, 'discussion_open': discussion_open})

Passing a flag is as simple as that. You accessed a field on the retrieved book and if the date has already passed (or is today), the discussion_open is set to true.

Now you use that flag in the template "bookclub/templates/bookclub/book_detail.html":

<!--bookclub/templates/bookclub/book_detail.html-->
<!-- extends and block title here-->

{% block content %}
<div class="card">
    <div class="card-body">
        {{ book.description}}

        {% if not discussion_open %}
        <div class="alert alert-primary mt-4" role="alert">
            Read this book by: {{book.read_by}}
        </div>
        {% endif %}
    </div>
</div>

{% if discussion_open %}
<p class="success"> Discussion is opened. </p>
{% else %}
<p class="alert"> Discussion is not enabled yet for this book.</p>
{% endif %}
{% endblock %}

You added 2 if blocks. If the discussion_open is false, you display the deadline inside the card. At the bottom, you display two different notices, based on if the deadline has already passed or not.

As for the books whose deadline has not passed yet, you covered everything. As for the books that should have discussion enabled, this is the next thing you're going to do.

Discussion model

You'll need another model for the discussion. Each instance of the Discussion model will be connected to one of the Book instances and one of the User instances via foreign keys.

# bookclub/models.py

from django.db import models


class Book(models.Model):
# ...


class Discussion(models.Model):
    book = models.ForeignKey('bookclub.Book', related_name='discussion', on_delete=models.CASCADE)
    author = models.ForeignKey('auth.User', related_name='records', on_delete=models.CASCADE)
    opinion = models.TextField()

You have the opinion (TextField) for the Discussion instance and two foreign keys we already mentioned - the book for which comment is intended and the author of the comment.

ForeignKey is a field that represents many-to-one relationships. In this case, you're connecting the Discussion model with Book model you created and with Django's out-of-the-box User model.

The first positional argument in the ForeignKey class is the class to which the model is related (in our case bookclub.Book and auth.User) and it is required.

You can access models in another application by specifying the name of the application first (auth); the second part is the name of the model (.User).

on_delete specifies what happens with the instances of the current model if the model accessed with ForeignKey is deleted (eg. if you delete the book, you'd want all the comments on a said book to be deleted too. That's what you achieve by models.CASCADE).

related_name is a name by which you can access the Discussion instances from the related Model (Book or User). Later you'll be able to see that we can access all the discussion for a book with book.discussion. .discussion being the related name we just assigned.

You made a change to your models, but your database has not been notified yet.

Run the following commands in your terminal:

(env)$ python manage.py makemigrations
(env)$ python manage.py migrate

Django forms

Django makes it easy to handle forms. It prepares and restructures data to make it ready for rendering, creates HTML forms, receives and processes submitted data from the client. You'll create a form that will correspond to the Discussion model. This means you'll define a ModelForm.

Define a DiscussionForm in "bookclub/forms.py":

# bookclub/forms.py
from django import forms
from bookclub.models import Discussion

class DiscussionForm(forms.ModelForm):

    class Meta:
        model = Discussion
        fields = ('opinion',)

In the class Meta, you defined that you're going to connect the form with the Discussion model and the only field you have is the opinion.

fields have to be passed as a tuple. That means that even if you're passing only one field, the () and the , are necessary.

You need to process the form you created inside the book_detail view in "bookclub/views.py":

# bookclub/views.py
from datetime import date
from django.shortcuts import render, get_object_or_404, redirect
from django.http import HttpResponseForbidden
from bookclub.forms import DiscussionForm
from bookclub.models import Book

def book_detail(request, pk):
    book = get_object_or_404(Book, pk=pk)
    discussion_form = DiscussionForm()
    discussion_open = False

    if book.read_by <= date.today():
        discussion_open = True

    if request.method == "POST":
        form = DiscussionForm(request.POST)

        if not request.user.is_anonymous:

            if form.is_valid():
                opinion = form.save(commit=False)
                opinion.author = request.user
                opinion.book = book
                opinion.save()

                return redirect('book_detail', pk=book.pk)
        else:
            return HttpResponseForbidden("Forbidden")

    return render(request, 'bookclub/book_detail.html', {'book': book, 'discussion_open': discussion_open, 'discussion_form': discussion_form})

You added a new instance of DiscussionForm in the book_detail view, and you passed it to the template. That's all that is needed for displaying it.

But when the user submits it, you need to do a little more:

• you create an instance of the DiscussionForm and fill it with the data retrieved from the request
• you check if the user is anonymous and if they are, you return HttpResponseForbidden("Forbidden"). That way, you prevent unauthenticated users to post comments.
• you use built-in form validation to check if the form is valid
• commit=False means you don't want to save the form yet - first you need to add the data that was not supplied by the user
• You can't allow the user to select the author or the discussion post on their own, you add it while processing the form:
  • author is the person that submitted the request
  • since the form is displayed on the page for the single book, you know exactly for which book it was submitted. You pass the book you retrieved already to display it to the form.
• you save the form manually since you prevented it from saving it in the first place

The last thing to do is to display the form in the template "bookclub/templates/bookclub/book_detail.html":

<!--bookclub/templates/bookclub/book_detail.html-->
<!--...-->
<!--<h2 class="mt-5 mb-3">Discussion</h2>-->
<!--{% if discussion_open %}-->

    <b>What are your thoughts on the book?</b>
    {% if user.is_authenticated %}
    <form method="post">
        {% csrf_token %}
        {{ discussion_form.as_table }}
        <br>
        <button type="submit" class="btn btn-primary mt-2">Submit</button>
    </form>
    {% else %}
    <div class="alert alert-warning">Only registered users are allowed to post their opinion.</div>
    {% endif %}

<!--{% else %}-->
<!--...-->

Since posting a comment is allowed only to registered users, you check if the user is logged in with {% if user.is_authenticated %}.

From here on, we're working with a logged-in user. If you're able to see the "Only registered users are allowed to post their opinion.", navigate to http://127.0.0.1:8000/admin/login/ and login with your superuser.

Using the csrf_token provides protection against Cross Site Request Forgeries.

You can display the form you created in many ways. Here you simply rendered the whole form as a table. You also could display just the one field without the label, it would be prettier, but would mean unnecessary complications.

The form looks less than ideal, but we're changing it right at the beginning of the second part - COMING SOON, don't worry.

Displaying the discussion

You should now be able to post your opinion via the form, but you can't check that. You don't see it nor on the single book page, nor in the admin panel.

First, make it visible in the admin panel. Edit "bookclub/admin.py" and add the Disccussion the same way you added the Book:

# bookclub/admin.py

from django.contrib import admin
from .models import Book, Discussion

admin.site.register(Book)
admin.site.register(Discussion)

If you open the http://127.0.0.1:8000/admin/, you'll be able to see the Discussions on the left side. You can edit them or add them here if necessary.

You may expect that you need to get all the values from the Discussion in the view first. But that's the magic of Django - you can simply access it via the Book in the template. Add the folowing code under the form inside the {% if discussion_open %} in the bookclub/templates/bookclub/book_detail.html:

<!--templates/bookclub/book_detail.html-->
<!--    ... -->
<!--    {% else %}-->
<!--    <div class="alert alert-warning">Only registered users are allowed to post their opinion.</div>-->
<!--    {% endif %}-->

    {% for opinion in book.discussion.all %}
    <div class="card mt-4">
      <div class="card-header">
        {{ opinion.author }}
      </div>
      <div class="card-body">
        <p class="card-text">{{ opinion.opinion }}</p>
      </div>
    </div>
    {% empty %}
    <div class="alert alert-secondary mt-4" role="alert">
    There is no opinions yet for this book.
    </div>
    {% endfor %}

<!--{% else %}-->
<!--<div class="alert alert-secondary" role="alert">-->
<!--    Discussion is not enabled yet for this book.-->
<!--...-->

This is the beauty of Django - you access all the opinions users posted under a particular book with book.discussion.all. Inside the for tags, you access its fields the same ways for the book - opinion.field. Another thing you may noticed - {% empty %} tag. This is a tag, used inside the for loop that executes if the list you loop through is empty. If there's a discussion going on under the book, the details about every opinion will be displayed. But if there's no discussion, the alert about no opinions will get displayed.

This means that instead of {% if book.discussion.all %} ... {% else %} you get to use {% empty %}.

Display the latest book for discussion

Currently, discussing the book is not the first thing that comes to the user's mind when on your webpage. Turn their attention to it by displaying the latest book they should read.

Add a 'featured' box at the top of your "bookclub/templates/bookclub/book_detail.html":

<!--bookclub/templates/bookclub/book_detail.html-->
<!--...-->
<!--{% block content %}-->
{% if previous_books %}
<div class="jumbotron">
    <p class="lead">What were your thoughts on the latest book?</p>
    <h3>{{previous_books.0.book}}</h3>
    <hr class="my-4">
    <p>{{previous_books.0.description|truncatewords:150}}</p>
    <a class="btn btn-primary btn-lg" href="{% url 'book_detail' pk=previous_books.0.pk %}" role="button">See the discussion</a>
</div>
{% endif %}
<!--<ul class="nav ... -->

All you did here is select the first book from the array of the previous books and displayed its data. To avoid an ugly error if there are no previous_books, you need to first check if there are any previous books.

Conclusion

The pool of knowledge of Django is deep and wide. You've only scratched a surface, but even with that, you can create a lot. Now you know how to create a Django project and an app in it. You learned a good flow for creating a page: Model -> Url -> View -> Template You learned about template extending and how to make your pages prettier with Bootstrap.

The whole code can be found on GitLab.

This tutorial is the first in a series that covers Django from first steps to deployment. Feel free to stick around for the whole series. In the second part - COMING SOON, you'll learn how to customize the admin interface, use Django packages, add custom CSS...

• Basic knowledge of Python

• Basic understanding of Django framework

REST API

Rest API is a term concatenated from 2 abbreviations.

• REST stands for REpresentational State Transfer

• API stands for Application Programming Interface

REST is an architectural style for distributed hypermedia systems that abide by some rules.

• Client and server sides are separated.

• Each request from the client to the server must contain all of the information (it is stateless).

• Interface is uniformed (all the API points should be accessible by a similar approach).

API is a specification by some software that allows other programs to interact with it. It allows a developer to make a specific request to send or receive information.

So, REST API is a web service for programs that uses REST architectural style and abides by its rules.

Django REST Framework

Django REST Framework is a powerful tool for creating REST APIs based on Django. It comes with built-in serialization, authentication and it's highly customizable. Besides that, APIs built with it are browsable out of the box. That means that you're able to use it almost like a simple web application. You can add data and view it in a browser.

Another great thing is that it comes with great documentation.

Squats, pushups, and API

A bunch of programmer friends decided they want to do more for their bodies. They plan to do as many pushups and squats as they can each day and compete against each other. The person that does the most of both at the end of the period, gets a reward.

Since they're programmers, each of them will create their own client and analyze data in their own way. To be able to see where the competitors are, they need an API. They'll send their daily record to the API and will be able to retrieve data about others back.

Each day, they'll post how many pushups and squats they did, but they don't need daily records of others back. They just need to know the total count of both for every other competitor.

Initial setup

Start with creating a project and virtual environment:

$ mkdir health_challenge
$ python3.9 -m venv env
$ source env/bin/activate

Next, install Django and Django Rest Framework:

(env)$ pip install django
(env)$ pip install djangorestframework

After that, create a new Django project and app:

(env)$ django-admin.py startproject tutorial .
(env)$ django-admin.py startapp challenge

adding a dot after the name of the project prevents Django from creating a redundant parent directory

Once the project is created, register Django Rest Framework (DRF) and the challenge app to installed apps inside "tutorial/settings.py" :

# tutorial/settings.py
INSTALLED_APPS = [
    # ...
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',
    'challenge',
]

Models

Create a Record model inside the "challenge/models.py":

# challenge/models.py
from django.utils import timezone
from django.db import models

class Record(models.Model):
    date = models.DateField(default=timezone.now)
    pushups = models.PositiveIntegerField(default=0)
    squats = models.PositiveIntegerField(default=0)

    def __str__(self):
        return self.date

For now, it has 3 attributes: date, pushups, and squats. You'll add the creator later.

Create an initial migration and apply it:

(env)$ python manage.py makemigrations
(env)$ python manage.py migrate

Register the Record model in challenge/admin.py so you can access it from the Django admin panel:

# challenge/admin.py
from django.contrib import admin
from challenge.models import Record

admin.site.register(Record)

If you want to access the admin panel to check your work, you have to create a superuser:

(env)$ python manage.py createsuperuser

Enter the required data (remember the password!).

Now, run the local server for the very first time:

(env)$ python manage.py runserver

Navigate to the admin panel in your application: http://127.0.0.1:8000/admin/ and open Records. Add 2 new records.

Serializers

Instead of a page composed of HTML, CSS, and JS, an API only provides raw data. That data needs to be in some kind of form that it's easy for a program to extract it (JSON/XML). In DRF, Serializer takes care of that. DRF Serializer covers serialization and deserialization of data and its validation. There are two possible classes to use when you need a serializer. Serializer class is a powerful generic way to control the output, ModelSerializer is a specialized serializer for model instances. Considering you're working with your models, you'll use the second one.

Create a new file serializers.py inside challenge directory:

# challenge/serializers.py
from rest_framework import serializers
from .models import Record


class RecordSerializer(serializers.ModelSerializer):
    class Meta:
        model = Record
        fields = ("id", "date", "pushups", "squats")

ModelSerializerclass creates a Serializer with a set of fields that corresponds to the selected Model. As you can see, you had to import the serializer and the Record model.

Inside the ModelSerializer there's a class Meta in which you specify which model you want to use and which fields from the Model to serialize.

Even if you want to serialize all the data, it is recommended to specify each field explicitly. That saves you from exposing too much data by accident if you change your Model. Ignoring that, you can specify all the fields with fields = "__all__".

View

Since you're not building a typical website, you won't use a classical Django View. DRF provides a View subclass - APIView.

GenericAPIView which extends APIView, provides concrete generic views that cover commonly required behaviors for lists and detail views.

There are quite a few concrete generic views you could use:

• CreateAPIView is used for resource creation endpoints

• ListCreateAPIView is used for a read-write list of resources

• RetrieveUpdateDestroyAPIView is used for read-write-delete on single resource

• ...

You can check all of them here

Since you're creating an endpoint for posting the records, you'll use CreateAPIView generic view. Create a new file view.py:

from rest_framework import generics
from .serializers import RecordSerializer


class RecordAdd(generics.CreateAPIView):
    serializer_class = RecordSerializer

There is no data to retrieve, so you just need to set the serializer_class to the previously created RecordSerializer.

URL

The last thing to do is to add an url where you can access your view. Create an urls.py inside the challenge folder.

# challenge/urls.py
from django.urls import path
from .views import RecordAdd

urlpatterns = [
    path('add-record', RecordAdd.as_view())
]

After that, include that file inside "tutorial/urls.py":

#tutorial/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path("", include("challenge.urls")),
]

Now you can navigate to http://127.0.0.1:8000/add-record and voila:

Your first API endpoint!

Add a record and go check it in the admin panel: http://127.0.0.1:8000/admin/challenge/record/. You should see the record you entered via API!

Record owners

If your app is about the competition between record creators, you need to be able to assign created records to a user. That's how you'll know who made that many pushups.

Start by changing a Record model. You need to add a creator field to it.

# challenge/models.py
# ...

class Record(models.Model):
    date = models.DateField(default=timezone.now)
    pushups = models.PositiveIntegerField(default=0)
    squats = models.PositiveIntegerField(default=0)
    creator = models.ForeignKey('auth.User', on_delete=models.CASCADE)

# ...

Stop the local server with Ctrl+C and run (env)$ python manage.py makemigrations. Since you've already created some records it won't go as easy as the first time.

You'll get asked the following:

You are trying to add a non-nullable field 'creator' to record without a default; you can't do that (the database needs something to populate existing rows).
Please select a fix:
 1) Provide a one-off default now (will be set on all existing rows with a null value for this column)
 2) Quit, and let me add a default in models.py

Select 1 and type 1 in again, so your superuser will be the creator of current records. Sync your database with (env)$ python manage.py migrate.

Make some minor changes, so you can check if your Model change works as it should.

First, create another superuser: shell (env)$ python manage.py createsuperuser Next, add a login to the browsable API. Include rest_framework.urls in the "tutorial/urls.py":

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
  path('admin/', admin.site.urls),
  path('api-auth/', include('rest_framework.urls')),
  path("", include("challenge.urls")),
]

If you refresh the page (http://127.0.0.1:8000/add-record), you'll see a little arrow next to your username on the right side of the page:

Click on it and you can logout and login with the other superuser you created.

After that, change the list display for records admin. Add a RecordAdmin with the list_display specified to the "challenge/admin.py":

# challenge/admin.py
from django.contrib import admin
from challenge.models import Record

class RecordAdmin(admin.ModelAdmin):
    list_display = ('date', 'creator')

admin.site.register(Record, RecordAdmin)

This is not necessary, solely intent of this is that you can easily see who's the records creator.

Now, logged in as another user, try to create a new record via browsable API and... Ups, you've got an error.

NOT NULL constraint failed: challenge_record.creator_id

That's because now you demand a creator in your model, but you didn't provide it. You don't want to add it via form, as you did it for other data. You want for the creator to be automatically added, based on which user posted the new record. You can hook on the objects save method in your view and overwrite it, so creator = user.

# challenge/views.py
# imports here

class RecordAdd(generics.CreateAPIView):
    serializer_class = RecordSerializer

    def perform_create(self, serializer):
        serializer.save(creator=self.request.user)

Try to create a record, logged in as another user again and you should see no error. Now, go check the records admin panel at http://127.0.0.1:8000/admin/challenge/record/ and you can see that you created another record with a different user.

List all users with their records

You covered the posting-the-record part. Now move to the second part of your requirements - getting the data for all the competitors. Before you proceed and make things complicated, start simple.

First, add a serializer CompareSerializer inside "challenge/serializers.py*:

# challenge/serializers.py
# imports and RecordSerializer here

class CompareSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ("__all__")

You retrieve all the data that you have on each user.

Next, add a new view inside "challenge/views.py":

# challenge/views.py
# imports and RecordAdd here
from .serializers import RecordSerializer, CompareSerializer
from django.contrib.auth.models import User


class CompareView(generics.ListAPIView):
    queryset = User.objects.all()
    serializer_class = CompareSerializer

There are some differences with the RecordAdd view:

1. Instead of CreateAPIView, you use ListAPIView - that's because you don't want to add a new record but to see all the records.

2. You didn't need the queryset for RecordAdd, because you didn't do anything with previous records. Now you're showing all the records, so you need to retrieve them.

3. You used the CompareSerializer instead of RecordSerializer

After that, add an url to "challenge/urls.py":

# challenge/urls.py
# imports here

urlpatterns = [
    path('add-record', RecordAdd.as_view()),
    path('compare', CompareView.as_view())
]

Now navigate to http://127.0.0.1:8000/compare and ... - ok, it's working but it's not the data you need.

SerializerMethodFields

SerializerMethodField is a read-only field that gets its value by calling a method on its Serializer. You can use it to add any sort of data to your serialized object.

Edit your CompareSerializer:

# challenge/serializers.py
from django.db.models import Sum
# other imports and RecordSerializer

class CompareSerializer(serializers.ModelSerializer):
    pushups = serializers.SerializerMethodField()

    class Meta:
        model = User
        fields = ("username", "pushups")

    def get_pushups(self, obj):
        return obj.records.aggregate(Sum('pushups'))['pushups__sum']

SerializerMethodField and its method are automatically connected with a DRF method get_<field_name>. That means that the belonging method has the same name as the field, just prefixed with get_. You need to add the SerializerMethodField to the Serializers fields.

Now for the method: obj refers to the instance of Model you're using for your Serializer. .aggregate is a Django's function that summarizes a collection of objects and with Sum, you calculate their sum. obj.records.aggregate(Sum('pushups'))returns a dictionary, so you add ['pushups__sum'] to access just the desired key.

Refresh http://127.0.0.1:8000/compare and check if it works.

You got the count of pushups! To provide all the data you wanted, you just need to do the same for the squats.

class CompareSerializer(serializers.ModelSerializer):
    pushups = serializers.SerializerMethodField()
    squats = serializers.SerializerMethodField()

    class Meta:
        model = User
        fields = ("username", "pushups", "squats")

    def get_pushups(self, obj):
        return obj.records.aggregate(Sum('pushups'))['pushups__sum']

    def get_squats(self, obj):
        return obj.records.aggregate(Sum('squats'))['squats__sum']

You added another SerializerMethodFIeld and its method. Don't forget to add this method field to the list of fields inside the Meta class. Refresh the page and the second APIView is completed!

Limit the API solely to authenticated users

You don't want the data of your users to be seen by anyone who just wanders around your API. You want to limit the access to this API point. There are 3 options for limiting the access:

• Project-level (restrict the access to the whole API)

• View-level (restrict the access to whole API View)

• Object-level (restrict the access only for part of the view)

Default permission policy

Currently, you don't want someone that is not registered, to see anything. You'll restrict access to your API globally. Edit "tutorial/setting.py" and add this at the bottom:

REST_FRAMEWORK = {
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticated',
    ]
}

With this, you allow access to your API only to authenticated users. Logout from the API and you'll see this:

Even if you navigate to /add-record, the message you will be the same.

Remember how to do that, but for now, delete the code you added in the settings.py file (REST_FRAMEWORK ... IsAuthenticated',]}). You need to learn about another possibility.

View level permission

Let's say the family and friends of the competitors want to monitor the competition. You want them to see the list of competitors, but you don't want them to add the records. If they'd try, they'd get a nasty error:

You don't want that. You want to limit the access for the add-record endpoint.

Edit the RecordAdd class in "challenge/views.py":

# challenge/views.py

from rest_framework.permissions import IsAuthenticated # don't forget the import!

class RecordAdd(generics.CreateAPIView):
    permission_classes = [IsAuthenticated]

    serializer_class = RecordSerializer

    # ...

Open http://127.0.0.1:8000/add-record. You're logged out, so this is the view you get to see:

Now navigate to http://127.0.0.1:8000/compare. Even when you're logged out, your view is the same as for an authenticated user:

If you log in and go back to /add-record, you'll be able to post a new record:

Check all the possibilities of the restrictions here.

Root API Endpoint

You can make your API easier to browse. On your root page(/), you want to make a list of all the endpoints.

For that, you need to create another view and connect it with the root url.

For this, you don't need Serializer, you'll use just a simple Django function-based view.

Add this at the top of the "challenge/views.py"e:

# challenge/views.py
# ... imports here
@api_view()
def api_root(request, format=None):
    return Response({
        'add': reverse('add-record', request=request, format=format),
        'compare': reverse('compare', request=request, format=format)
    })

# ... RecordAdd and CompareView here

Django receives an instance of HttpRequest and returns HttpResponse, but DRF receives an instance of Request and returns Response. To change a Django view to a DRF view, use the @api_view decorator. You provide both API points in the Response. reverse returns a fully qualified URL, using the request to determine the host and port. That way, the urls are correct, either on your localhost or in the production, without the need to change anything in the code.

add-record inside the reverse method corresponds to the name of the url. You don't have that in your "challenge/urls.py". Add it:

# challenge/urls.py

from django.urls import path

from .views import RecordAdd, CreatorList, CompareView, api_root

urlpatterns = [
    path('add-record', RecordAdd.as_view(), name='add-record'),
    path('compare', CompareView.as_view(), name='compare'),
    path('', api_root)
]

You imported the api_root view you wrote a few minutes back and added it to the root of your website. To the paths add-record and compare you added names, so the reverse function in api_root can find them.

Open http://127.0.0.1:8000/ and check it yourself - it works!

You can also click on links of add and compare and that makes it easy to navigate through your API.

Conclusion

You're now able to create a REST API with Django Rest Framework. You know how to create views that either allow you to post or to retrieve data. You know how to create serializers that change your Model data to JSON. You learned how to restrict access and how to make your API browsable. You also learned how to change the data you get from the Models and serve the change data on your API.

You can play around with it a little more:

• create an endpoint that will output the current winner

create an endpoint where only an owner will be able to see and change/delete their record

If you're looking for more advanced content, you can check the articles on DRF that I wrote on Testdriven.io:
- Django REST Framework Views series
- Permissions in Django REST Framework series

_{Image by slightly_different on Pixabay}

Place for our voice

Although the end goal is to make men and women equally present in the tech field, we're not there yet. And striving toward that goal means that we need to take some measures until those measures will eventually become obsolete. That means special treatment of women.

It's hard for the only woman in the team to speak up.

It's hard for a female developer on Twitter to be loud when she sees 20 'Twitter-famous' female developers and 200 male ones.

It's hard for a woman to go to a conference where she'll be surrounded by male developers.

That's why special places need to exist.

Places, where she doesn't need to be brave to speak.

Places, where she's especially welcomed.

That's why I'm glad #choosetochallenge exists.

That's why I love it when there are some tickets at the event reserved especially for women.

And that's why I occasionally create a tweet where people are invited to tag only women coders, not everyone.

And that's why I have an invitation for female coders to write to me in my Twitter bio.

Because we need that special place, for now.

Inappropriate behavior

There are very obvious inappropriate behaviors that put women in an inferior position. Like a male coworker's uninvited sexual attention towards you. Or your coworkers commenting on a physical appearance of a client or a coworker. The workplace is not a place where this kind of behavior should be tolerated.

But there are less obvious acts that are hurtful toward women:

• Saying that a woman in tech/any other male-dominated career is unfeminine

  No behavior makes a woman more or less feminine. She is who she is.

• Being surprised she can do something despite her being a woman

  Admiring some skill some woman has is great. But singing her praises just because she did something that is not expected for her gender (like hammering a nail in) is sexist.

• Expecting her to do something just because she's a woman is sexist.

  Always putting the task of writing notes during a meeting to a woman, because she probably 'has a pretty handwriting' is sexist and not appropriate for the 21st century.

• Sexist jokes

  Just because you camouflage it as a joke, it doesn't mean it's ok.

Future generations

Changes this big take time. And even though many of us are taking the steps toward reshaping the perception of women in tech, a non-gender biased environment in tech is probably something that only future generations will be able to experience.

Teach your daughters, nieces, and other little girls that they can do whatever they put their minds to, not just 'girl' things. Try to spark their interest in science, math, and programming. Don't teach your kids about 'male' and 'female' roles. Teach your sons and nephews to respect women and that household chores are something that should be done by "people", not by women.

Don't limit a little woman to your expectations. Her wanting to wear a blue shirt and playing with dinosaurs is great. Her wearing a pink skirt and playing with barbies is great.

I once saw a little girl in a skirt playing soccer. She was the best little goalkeeper I ever saw. It was awesome. She took something considered 'feminine' and something considered 'masculine' and made it her own.

Motherhood

Becoming a parent changes a lot and this is more true for the mothers. Pregnancy many times requires either to work less or take the time off and in the countries that have maternity leave, that means leaving the workforce for a while. When coming back, you have a tiny human being to take care of and that makes a good work-life balance a necessity. According to the research by Christine L. Williams, mothers and prospective mothers experience intense work-life conflict.

We need to stop equating a good employee with an employee that works long hours. That puts mothers at an unfair disadvantage. Even if she's highly efficient, she isn't perceived like that, because she doesn't work long hours and she takes time off to take care of a sick child. We also need to stop allowing for maternity leave to affect the career. Temporarily leaving a job to take care of a little human being that on your old age might be your doctor or your kind neighbor is important, not just for her and her child, but also for you. And it should be respected, not looked down on.

The expectation of a woman having a kid and start working less also concerns the child-less. Employees will expect her to have a child eventually and will be reluctant to give her a job in the first-place or promotion later in the career.

Pandemic hit mothers hard.

According to The New York Times, 900.000 mothers left the workforce due to pandemic in the USA.

I, living in Europe, had to revise my career plans because kindergartens were closed for months and can close again in a matter of days. Once the pandemic is over, we need to do everything in our power to help those women to get back in the workforce. And we must not see them leaving as a weakness and something that puts them at a disadvantage. They already made their sacrifice, let's not make them sacrifice even more.

Final thoughts

The coding world is a world of great opportunities. But in a world where women are so scarce, it can be hard being a woman.

If you're a woman, be brave, so the next generations won't need to be.

If you're a man, don't be mad if we get special treatment. We need it, so we won't need it anymore.

Happy International Women's day!

When you start learning you create an application, maybe even deploy it on some free server, but that's it. There is no unsatisfied customer that found some error, there is no client that changed their requirements 3 hours after you pushed to production. There is also no code maintenance. In reality, software is a living thing.

In a real-life, you'll keep changing your code, adding new requirements, fixing bugs. And that can get messy after a while.

There are some practices that make it easier for you. One of those is Test Driven Development.

Requirements

Since this is not a tutorial, you don't really need any knowledge to read it. However, I assume that you know enough Python to be able to follow.

What is Test Driven Development

Test-Driven Development with the abbreviation TDD is a methodology in software development where you write a test for function before it is implemented.

Writing TDD means writing in a cycle:

1. RED - write failing test

2. GREEN - write the simplest piece of code that will get the test to pass

3. REFACTOR - improve the code while keeping the test pass

Although it seems that it takes a longer time to develop that way, it saves you a lot of time after you've mastered it. Similarly, it costs you a lot of nerves when you start learning it but it saves you a lot of nerves in a long run.

Palindrome example

I wrote a simple function, that checks if a string is a palindrome. The only palindrome I know on the top of my head is the word "tat" (it means a thief in my language).

A word is very simple to check: you just have to revert it. If words are the same, you know that is a palindrome. You don't naturally think about 10 other cases in which that maybe wouldn't work. It works and that's enough.

But, because I was practicing TDD, I had more cases that got run. It turned out that my function didn't work for sentences. Sentences included capital letters, spaces, and punctuations. Because of TDD, I quickly figured out I need to remove special characters and spaces.

That mistake is easy to catch, but when your code is more complex, it can take a lot of time to figure out that something is not okay and how to fix that.

What I was doing

For my first project, I selected something simple. If I would be developing something complex, my focus would be on the development of the program instead of on learning TDD.

I was building an expense tracker where the user can enter an amount, date, and description of expense via CLI which is stored in the database. It's also possible for the user to list existing expenses.

To build it I used:

• Python

• pytest

• TXT file as a database

Given, when and then

Given, when, then is a structure that you can use to describe the expected behavior of the unit under test. In Python you can write it as a docstring:

"""
GIVEN:  initial conditions for the test
WHEN:   what is occurring that needs to be tested?
THEN:   expected outcome
"""

I always wrote that docstring first and use it as a guideline to write the test. It's also easier to see what's going on for someone who sees the test for the first time.

My first test

First, I installed pytest. It's a Python library for writing automated tests. I started with a unit test. The unit test is a test that tests a small part of the program in isolation of other parts. To check whether those units work together correctly you use integration and end-to-end tests. When I started writing the test for my first function there was no code yet. At this point, function user_input_divide, existed only in my head. So I wrote a test for it:

def test_user_input_divide(): #1
    #2
    """
    GIVEN user input
    WHEN user_input_divide is called
    THEN input is divided into 3 pieces (amount, date, description)
    """

    raw_input = "33.22;2020-11-05;This is a description" #3
    amount, date, description = user_input_divide(raw_input) #4

    #5
    assert amount == "33.22"
    assert date == "2020-11-05"
    assert description == "This is a description"

1. name of the test function must be prepended with test_ - pytest automatically discover and runs functions with test_ prefix

2. Given, when, then formula:

   • Given a user input -in this function I do not care how will I get user input, I just assume it exists and it's in the correct form.

   • the function user_input_divide is going to be called user_input_divide

   • as a result user's input must be divided into 3 pieces - amount, date, description

3. valid user's input for the function

4. function user_input_divide is called to divide the input - the function user_input_divide doesn't exist yet.

5. assert is a standard Python statement that can be used with pytest. On the left side, you provide the actual outcome of the function and on the right side, you provide the expected outcome. == in the middle means that you expect that both sides will be equal

After that, I ran the test with the command:

pytest

The test, of course, fails.

Once I had a failing test I implemented a function with a hardcoded result.

def user_input_divide(raw_input):
    return ["33.22", "2020-11-05", "This is a description"]

I run the test again and it failed - again.

Why? Let's read the error:

NameError: name 'user_input_divide' is not defined

Of course, I haven't imported the function into my test module yet.

That should fix it:

from expense.user_input import three_part_input, user_input_divide

def test_user_input_divide(): #1
    ...

I run the test again, it passed.

But that didn't cut it. That function didn't do anything, I just knew that everything is connected the right way.

I changed the function from hardcoded to real implementation:

def user_input_divide(raw_input):
    return raw_input.split(";")

I run the test and it passed.

This article didn't go into detail regarding pytest.
If you want to learn more. check out my Pytest for beginners article.

Where to next?

Imagine TDD like building something with Legos. First, you create all the lego blocks, and only after that, you put them together. Following the expense tracker example, it would go something like this:

• Splitting user input into 3 separated parts - DONE

• Checking if all the data is in a correct form (date in form of YYYY-mm-dd, the amount in a form of a float)

• Currently, all the data is in a string - you need to transform the amount into a float and date into a datetime object

• Put date into the object

• Persist the object to a database

For each of these, you first need to write a test. Only after that, you put all that together and test if it works correctly altogether.

Conclusion

This was not meant to teach you test-driven development but to introduce it to you. I hope I sparked a little interest in TDD. It's a great way towards easier development, maintenance, and upgrading. I recently started learning TDD, so you can follow my journey here. I'm also planning to create beginner-friendly tutorials in the future.

Photo by Samuele Errico Piccarini on Unsplash

In this tutorial, you'll create a stylish accordion. Along the way, you'll learn how to combine ::before and ::after to create a beautiful effect, how to toggle class and content, and many more.

Prerequisites

• basic knowledge of HTML
• basic knowledge of CSS
• basic knowledge of JS

Pretty bullet

Let's start building with pretty bullet. First, create a new file accordion.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Beautifull accordion</title>
    <link rel="stylesheet" href="accordion.css">
    <script src="https://code.jquery.com/jquery-3.5.1.min.js" integrity="sha256-9/aliU8dGd2tb6OSsuzixeV4y/faTqgFtohetphbbj0=" crossorigin="anonymous"></script>
    <script src="accordion.js">
    </script>
</head>
<body>

<div class="accordion">
    <div class="tab">
        <h3 class="outer">
            Coding and programming careers have great earning potential
            <span class="inner"></span>
        </h3>
        <p class="hide">
            One of the strongest and most obvious draws of learning to code is the earning potential for coding and programming professionals. The Bureau of Labor Statistics (BLS) tracks salary and other important workforce information for a variety of careers.
        </p>
    </div>
</div>

</body>
</html>

Accordion will be built inside <div> with class accordion. It contains another <div> with class tab that contains:

• <h3 class="outer">- it contains key information and <span> that we'll be used create pretty bullet.
• <p class="innder"> - it contains more detailed information shown under the key information after click

At the moment there's a single accordion element. You'll add more of them later on.

After that, create a new file accordion.css:

.outer {
  position: relative;
  padding-left: 50px;
  line-height: 40px;
  color: #082c42;
}

.inner {
  position: absolute;
  left: 0;
}

.inner::before {
  content: url("images/button.svg");
  width: 40px;
  height: 40px;
  position: absolute;
}

.inner::after {
  content: "•";
  position: absolute;
  width: 40px;
  text-align: center;
  font-size: 40px;
  color: #082c42;
}

Here you have 4 elements on 3 levels:

• .outer is a container whose only purpose is to hold some text and .inner span.
• .inner that holds ::before/::after
• ::before and ::after

.outer is a container for your single bullet. The position of all the absolute positioned elements is based on a non-statically positioned ancestor. By setting the position to relative, you don't move the container, but you make it non-static, so all our absolute positioned elements will be positioned regarding the .outer. You set the line-height on .outer so all descendants will have the same line-height - that makes it easier to align them. With padding on the left, you get a little breathing room where you will now have space to put your pretty bullet.

.inner's purpose is to contain ::before and ::after. It doesn't hold anything but that. Both, ::before and ::after will be positioned furthest to the left, thus we position their parent as absolute with left: 0.

With the ::before's help, we show that pretty 3D button.

Next, create a new directory "images". After that, download the image for the bullet here and store it inside "images".

Because it's an SVG you're able to set width and height. That works because the element is positioned absolutely. By default, <span> is an inline element and you can't define its width or height. But any element that is positioned absolutely, automatically acts as a block element.

::after is containing a bullet(•). By making the element the same width and height you make it easier to put it in the middle of the larger circle just with text-align: center

Read about ::before and ::after here

Add JavaScript

Once you hace HTML and CSS ready you need to add JavaScript. Add a new file accordion.js.

$(document).ready(function() {
    $( ".outer" ).click(function() {
        $(this).closest(".tab").toggleClass("active");
    })
})

The color of the middle circle on the bullet should change when clicked on. You can accomplish that by adding another class on the parent tab of the clicked <h3 class="outer">. So when the user click on the <h3 class="outer">, parent tab is found by $(this).closest(".tab"). toggleClass is a wonderful jQuery function, that adds or removes a class.

You need to include jQuery and accordion.js inside accordion.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Beautifull accordion</title>
    <link rel="stylesheet" href="accordion.css">
    <script src="https://code.jquery.com/jquery-3.5.1.min.js" integrity="sha256-9/aliU8dGd2tb6OSsuzixeV4y/faTqgFtohetphbbj0=" crossorigin="anonymous"></script>
    <script src="accordion.js">
    </script>
</head>
<body>

<div class="accordion">
    <div class="tab">
        <h3 class="outer">
            Coding and programming careers have great earning potential
            <span class="inner"></span>
        </h3>
        <p class="hide">
            One of the strongest and most obvious draws of learning to code is the earning potential for coding and programming professionals. The Bureau of Labor Statistics (BLS) tracks salary and other important workforce information for a variety of careers.
        </p>
    </div>
</div>

</body>
</html>

Open accordion.html in your browser with Developer's tools opened. Try toggleClass functionality by clicking on <h3 class="outer">. You'll see that class gets added or removed on the .tab when you click. Visualy, there are no changes yet. To do that you have to target the smaller circle with .inner::after when .tab.active in your css and set it to different color:

.tab.active .inner::after {
    color: #bfd7ed;
}

Now, if you click on it repeatedly, it alternates colors based on class active.

Hide detailed content

Detailed content should not show at first. It should slowly slide down when you click on <h3 class="outer"> (when the tab is active) and slide back up when you click on it again.

To do that you need to add a new class to accordion.css:

.hide {
    display: none;
}

To add slide effect you need to use slideToggle function. Edit your accordion.js to look like this:

$(document).ready(function() {
    $( ".outer" ).click(function() {
        $(this).closest(".tab").toggleClass("active");
        $(this).siblings(".hide").slideToggle("slow");
    })
})

The added line is pretty similar to the previous one. It finds a sibling of the clicked element that has a class hide and toggles the slide. Now, when you click on the .outer, the bullet changes color, and the content either opens or closes.

Accordion

You can't really call it an accordion if it contains only one tab. so let's fix this. Edit your accordion.html to look like this:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Beautifull accordion</title>
    <link rel="stylesheet" href="accordion.css">
    <script src="https://code.jquery.com/jquery-3.5.1.min.js" integrity="sha256-9/aliU8dGd2tb6OSsuzixeV4y/faTqgFtohetphbbj0=" crossorigin="anonymous"></script>
    <script src="accordion.js">
    </script>
</head>
<body>

<div class="accordion">
    <div class="tab">
        <h3 class="outer">
            Coding and programming careers have great earning potential
            <span class="inner"></span>
        </h3>
        <p class="hide">
            One of the strongest and most obvious draws of learning to code is the earning potential for coding and programming professionals. The Bureau of Labor Statistics (BLS) tracks salary and other important workforce information for a variety of careers.
        </p>
    </div>
    <div class="tab">
        <h3 class="outer">
            Demand remains strong for coding-related jobs
            <span class="inner"></span>
        </h3>
        <p class="hide">
            When compared to the national average of five percent growth, you can see that a handful of positions are outpacing a lot of other careers. Computer programmers are an interesting outlier from this group, but some believe these projections are influenced by computer programming skills blending into other related in-demand tech roles.         </p>
    </div>
    <div class="tab">
        <h3 class="outer">
            Coding ability gives new perspective to problem-solving
            <span class="inner"></span>
        </h3>
        <p class="hide">
            Coding, in its most basic terms, is just assigning a computer a task to do based on the logical guidelines you’ve outlined. Highly complex tasks are essentially a collection of smaller operations once you break them down. This methodical and logic-heavy approach to problem-solving can be a boon for figuring out problems beyond a coding challenge.         </p>
    </div>
</div>

</body>
</html>

Your HTML stayed the same, except that you added two more tabs inside the accordion. Check your browser, you'll see that it still works as intended.

There's only one problem - it doesn't look like an accordion. It looks like a bunch of text that can be shown or hidden. To improve that, let's create a line on the left side that will connect all tabs.

Line on the left

The line should run at the middle of your bullets and be covered by them where necessary. If you want the freedom to move it as you like, you can't create it as a border but as its own element. You'll use ::before for creating it. Add these classes to accordion.css:

.accordion {
    position: relative;
}

.accordion .tab::before {
    border-left: solid #979797 1px;
    content: '';
    position: absolute;
    left: 20px;
    top: 0;
    bottom: 0;
    z-index: -1;
}

Although it looks like one line, it's created by multiple lines - from one tab to another. You want to take them(it) out of the page flow, so they're positioned absolutely. As mentioned before, you need to position an ancestor as relative for this to work - .accordion {position: relative;}. If you skip that step, you'll see that the line stretches through the whole browser.

The ::before doesn't have any content, just left border. left: 20px; positions it in the middle of the circle. z-index: -1; puts it behind the bullet and top: 0; bottom: 0; stretches it from beginning to the end of the tab.

It looks pretty when it's closed, right? Not so much when it's opened.

Let's fix that.

Small CSS repairs

You want to move the detaild text to the right, so it aligns with the key point text. To do that, add padding to .hide class inside accordion.css:

.hide {
    padding-left: 50px; /* newly added */
    display: none;
}

You also want to make the accordion narrower. To do that, limit max width of .accordion to 800px inside accordion.css:

.accordion {
    position: relative;
    max-width: 800px;
}

This looks much better, doesn't it?

Only one tab opened

For now, if you click on a tab, it opens and if you click on it again, it closes. Clicking on another tab has no impact on all the other tabs. But there should be only one tab open at a time. When you click on one tab it should open and all the others should close.

Once again, edit accordion.js:

$(document).ready(function() {
    $( ".outer" ).click(function() {
        $(this).closest(".tab").toggleClass("active");
        $(this).siblings(".hide").slideToggle("slow");
        $(this).closest(".tab").siblings(".tab.active").find(".hide").slideUp("slow") // added
        $(this).closest(".tab").siblings(".tab.active").removeClass("active") // added
    })
})

From the <h3> on which you clicked, it moves to its tab parent. Then it finds tab's siblings that have class active. If you did that correctly, there shouldn't be more than one active tab. After that, it slides up the child with class hide, and then it removes the active class from the found tab.

If you play around a little in your browser, you can see that now there is always max one tab open, but you can also close the open one.

If you paid attention, you'll notice that you're not finished yet. There's a little skip when the text is sliding up and it doesn't look good.

That's because you have an unwanted margin for <h3>. It is added by the browser.

Last CSS fixes

Because there's only one thing on your page, you won't include a whole file but just remove the border instead. Add margin: 0; to .outer inside accordion.css:

.outer {
  position: relative;
  padding-left: 50px;
  line-height: 40px;
  color: #082c42;
  margin: 0; /* newly added */
}

Another browser-applied border that makes things look wrong is margin-top on .hide. Set this to 0, too:

.hide {
    padding-left: 50px;
    display: none;
    margin-top: 0; /* newly added */
}

As you can see, you set the margin of .outer to 0 and when the text is closing it doesn't skip anymore. You also broke design, but that's easily fixable. Add a little padding at the bottom of .outer:

.outer {
    position: relative;
    padding-left: 50px;
    line-height: 40px;
    color: #082c42;
    cursor: pointer;
    margin: 0;
    padding-bottom: 15px; /* newly added */
}

Now you created another problem. Because of the padding, the line on the left side doesn't end with the last bullet. Padding should be applied for all the bullets except for the last one. You can find the last tab with :last-child and apply 0 padding at the bottom of its child .outer.

.tab:last-child .outer{
    padding-bottom: 0;
}

And this is it! Here's your pretty accordion:

In a real application, you'd probably want to use a CSS Reset file like this one or maybe a simpler one.

Conclusion

You have a pretty accordion to show, but you also learned so many things that you can use anywhere. You learned:

• How to combine ::before and ::after to create a beautiful effect
• How to toggle class
• How to apply different style by adding a class with JS
• How to toggle hidden/shown content
• That sometimes browsers break your design by applying their own

I hope you'll be able to create many more beautiful things with the knowledge you gained in this tutorial.

Whole code is visible here

Text taken from: https://www.rasmussen.edu/degrees/technology/blog/why-learn-to-code/

Regular Expression or RegEx for short is a tiny language that allows you to search matches in strings. In Python, it is accessible through the re module. Using it, you can check if the string is in the correct format, if the string contains some characters, extract only part of a long string,...

With a combination of metacharacters and literal characters, you concatenate a pattern used for search inside a string.

re module provides multiple different ways for searching for a pattern in a string.

1. re.match() Searches for a pattern at the beginning of the string and returns the first occurrence. It returns a match object if a pattern appears at the beginning of the string or None if there is no match at the beginning.

2. re.search() Searches for a pattern through the whole string and returns the first occurrence. It returns a match object if a pattern appears anywhere in the string or None if there is no match.

3. re.findall() Searches for all occurrences of the pattern in the whole string. It returns a list of all matches.

Syntax for RegEx is quite extensive. I don't provide a cheatsheet in this post, you can read through this one for more in-depth knowledge of the syntax

What will you learn?

We will go through some common cases of using RegEx:

1. Numbers
   1. Percents
   2. Decimals
   3. Amounts
2. Emails
   1. Correct format
   2. Extracting part of an email
3. Passwords
   1. Password strength errors
   2. Password validation
4. Date

Examples in this blog are not optimized and do not cover edge cases. Covering edge cases and optimization hurts readability and makes it harder to learn regex.

Prerequisites

• basic knowledge of Python

Numbers

Percents

import re

def get_percents(string):
    percent_pattern = r'[0-9]+%'

    percents = re.findall(percent_pattern, string)

    return percents

Searching for a percent pattern is one of the easiest. You search for at least one digit (it may be more) followed by a % sign.

"74% of girls express a desire for a career in STEM fields." => ["74%"]
"A whopping 80% of those in the field are male, while only 20% are female." => ["80%", "20%"]

This works only for integers. If you want to catch also decimal numbers, you need to combine it with RegEx for decimals.

Decimals

import re # import regex module

def get_decimals(string):
    decimal_pattern = r'[0-9]+[.,][0-9]+'

    decimal_numbers = re.findall(decimal_pattern, string)

    return decimal_numbers

Decimals look a little more complicated, but the basic idea is the same. You look for at least one digit, followed by either . or a , followed by at least one digit.

"The number π is approximately equal to 3.14159." => ["3.14159"]
"Niger: 7.03 children born/woman; Angola: 5.49 children born/woman; Madagascar: 4.36 children born/woman;" =>  ["7.03", "5.49", "4.36"]

Amounts

import re

def get_amount(string):
    amount_pattern = r'[0-9]+[.,]*[0-9]*[ ]*[€$]'

    amounts = re.findall(amount_pattern, string)

    return amounts

Considering many different styles, searching for an amount can be complicated. Here we checked for a basic example. At least one number (can be a decimal or integer) and a € or a $ sign at the end - they may be separated with space.

"In 2018, women in the US receive 250$ less than men when it comes to software development jobs." => ["250$"]
"Computer: 2600€, Mouse: 7.99 €, Screen: 99,9€" => ["2600€", "7.99 €", "99,9€"]

Email

Valid email

import re

def check_email_format(email):

    email_pattern = r'\S+@\S+\.\S+'

    # \S+ at least one char (greedy)
    # @, .  - exact match

    if re.match(email_pattern, email):
        return True

    else:
        return False

This is a very simple email check. You check if there are any amount of non-whitespace characters that are broken by @ and a . $%&#$@123.# would also be valid with this check.

"john@doe.com" => True
"%#$@1.2" => True
"python.org" => False

Improved valid email

import re

def check_email_format_improved(email):

    email_pattern_improved = r'[a-z0-9.]+@[a-z0-9]+\.[a-z]+'

    if re.match(email_pattern_improved, email):
        return True
    else:
        return False

Here you make stronger requirements. You want either lowercase characters or numbers ("gir1cod3") that are followed by @, followed by lowercase characters or numbers ("@gmai1"), a dot, and at least one lowercase character (".com").

"john@doe.com" => True
"%#$@1.2" => False
"python.org" => False

Get the recipient

import re

def get_recipient_from_mail(email_recipient):
    recipient_pattern = r'([a-z0-9.]+)@[a-z0-9]+\.[a-z]+'

    recipients = re.findall(recipient_pattern, email_recipient)

    return recipients

The pattern for a recipient is very similar to the improved valid email pattern. The only difference is, we added brackets (). If we include brackets, we're extracting only the part of the match inside the brackets. But we still need the whole match.

"We got an answer from python@python.org that was sent to john@doe.com" => ["python", "john"]
"We got a reply from most of the emails: python@python.org, john@doe.com. But we haven't got an answer from idontreply@whatever.com." => ["python", "john", "idontreply"]

Passwords

Password strength

You know when you get those annoying little messages, what you additionally need to put in your password because the current one is not strong enough? This is how you can do it:

import re

def password_check_parts(password):
    uppercase_pattern = r'[A-Z]'
    lowercase_pattern = r'[a-z]'
    number_pattern = r'[0-9]'
    special_pattern = r'[@#$%^&+=!.]'

    errors = []
    valid = False

    if not re.search(uppercase_pattern, password): # used search, because it can be anywhere in the string, match looks only at the beginning
        errors.append("Use at least one uppercase char")

    if not re.search(lowercase_pattern, password):
        errors.append("Use at least one lowercase char")

    if not re.search(number_pattern, password):
        errors.append("Use at least one number")

    if not re.search(special_pattern, password):
        errors.append("Use at least one special character")

    if not errors:
        valid = True

    return valid, errors

Here we have bunch of simple patterns, each one checking just for one thing. That way you know exactly what's missing in the provided password, not just that "something's wrong".

• [A-Z] => any uppercase character
• [a-z] => any lowercase character
• [0-9] => any digit
• [@#$%^&+=!.] => any character in the set; if the user uses * as their special character, this is gonna fail;

"something" => (False, ['Use at least one uppercase char', 'Use at least one number', 'Use at least one special character'])
"somethinG1" => (False, ['Use at least one special character'])
"12tesT3#" => (True, [])

Valid password

import re # import regex module

def password_valid(password):
    # at least one uppercase char, at least one lower case character, at least one number, at least one special char,

    # password_pattern = "[A-Za-z0-9@#$%^&+=]{8,}"

    password_pattern = r'(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[@#$%^&+=!.])'

    if re.match(password_pattern, password):
        return True
    else:
        return False

This regex is the hardest to understand in the whole post.

(?= creates a Lookahead. Lookahead means that although it checks if the pattern in the Lookahead brackets follows the current position of the regex engine. This part checks only immediately behind the regex engine's position. If you want it to look further, you have to add 'binoculars'. You do that by adding .*. That means that between the current position of the regex engine and the part that matches the pattern, can be any amount of any characters (including 0 or just whitespace). When putting all the searched patterns inside the Lookahead brackets, the regex engine doesn't move. It just checks if can see all the Lookahead patterns somewhere.

"Something123!" => True
"1tEsT@" => True
"#$%#1" => False

Date

Valid date

import re

def check_date_format(date):
    date_pattern = r'[0-9]{4}-[0-9]{2}-[0-9]{2}'

    if re.match(date_pattern, date):
        return True
    else:
        return False

We're looking for 4 numbers (year), 2 numbers (month), and 2 numbers (day), divided by -. The number in curly braces {} tells us exactly how many occurrences we want.

"2020-11-05" => True
"20-01-05" => False

Some text I used for examples, was taken from https://techjury.net/blog/women-in-technology-statistics/

Conclusion

The possibilities of using RegEx are almost limitless, here we covered only a few basic cases. Googling for the patterns usually gives you either very basic examples that help you nothing or complicated patterns you can copy, but can't understand. The patterns we created are not fireproof, rather they are meant to help you understand the idea behind regex.

After going through the examples you should be able to understand RegEx that was written by someone else, create your own, and improve our examples.

Photo by Skies & Scopes on Unsplash

We access elements we want to style in different ways, depending on what we want to style. Tags for general styling, classes for a group of elements, and IDs for single elements. But sometimes we need to overwrite a particular set of elements and it's useful to know how to target them as best as we can.

Sometimes you'll need to overwrite something that you don't have a complete view of (eg. spaghetti code in a large team) or complete access to (eg. bought WordPress theme). Developers usually tackle this by adding !important. That is not a good idea.

!important should only be used as a last resort.

At first, you have just one !important, then you write another one, to overwrite the previous one and so on and on. Try to force your CSS to be applied differently - by knowing the specificity rules.

Specificity rules are a way that the browser decides which of the conflicting CSS rules pointing to the same element will apply.

Here you have a graph, displaying specificity rules. On the left, there are rules depending on a selector (eg. tag, ID). On the right, there are rules, based on where the CSS style is applied.

At the top, they don't impact one another. However, when you start applying CSS rules inline, it collides with selector-applied rules. CSS applied inline, has higher specificity than the one, applied by any ID.

Below, I'll do a review example for each of the cases, so you can check it yourself. Each time, I'll compare 2 adjacent selectors/CSS positions.

Colors on the graph correspond with the assigned text color. Selectors and CSS usage colored gray, are not included in the comparison.

Based on the selector

You probably know that style, applied by ID overwrites style applied with class or tag. And that !important rules them all.

But there are few other rules mixed in-between. For example, a more extensively defined rule trumps the more basic one.

We will compare CSS selectors, listed bellow:

1. tag vs. class
2. 1 class vs. 2 classes on the same element
3. 2 classes on the same element vs. parent class + child class
4. parent class + child class vs. ID
5. ID vs. parentID + child class
6. parent ID + child class vs. parent ID + child ID
7. class with !important vs. parent ID + child ID
8. class with !important vs. ID with !important

tag vs. class

Tags are the easiest to overwrite.

CODE

HTML

<div class="class-over-tag">The 1st algorithm which was ever processed by a machine was written by the legend Ada Lovelace.</div>

CSS

.class-over-tag {
    color: darkgreen;
}

div {
    color: brown;
}

RESULT

1 class vs. 2 classes on the same element

More classes on the same element have a higher specificity than just a single class.

CODE

HTML

<div class="one-class another-class">Ever played Assasin’s Creed? If you have, you will be surprised to know that the producer of Assassin’s Creed is a programmer, Jade Raymond.</div>

CSS

.one-class.another-class {
    color: darkblue;
}

.one-class {
    color: darkgreen;
}

RESULT

2 classes on the same element vs. parent class + child class

2 classes on the same element have the same specificity as the class on the parent and the class on the child. That means the latter one overwrites the previous one. Here you can see both options:

CODE A

HTML

<div class="parent-class">
    <div class="child-class second-child-class">Sara Haider is currently working as a software engineer at Twitter. Known for her programming skills, Sara specializes in Android App development.</div>
</div>

CSS

.child-class.second-child-class {
    color: darkblue;
}

.parent-class .child-class {
    color: lightgreen;
}

RESULT A

CODE B

HTML

<div class="parent-class">
    <div class="child-class second-child-class">Sara Haider is currently working as a software engineer at Twitter. Known for her programming skills, Sara specializes in Android App development.</div>
</div>

CSS

.parent-class .child-class {
    color: lightgreen;
}

.child-class.second-child-class {
    color: darkblue;
}

RESULT B

parent class + child class vs. ID

Selecting an element directly by ID has a higher priority than combining parent and child class (or two classes on the said element).

CODE

HTML

<div class="parent-class">
    <div class="child-class" id="parent-child-vs-id">Corrinne Yu is known for her contribution to some famous games like Borderlands, Zombie, Unreal Engine 3 and Brothers in arms. Her most famous work is her contribution to the 2012 smash-hit game, Halo 4. She has also won a national award in 2009 for Nuclear Physics research.</div>
</div>

CSS

#parent-child-vs-id {
    color: lightblue;
}  

.parent-class .child-class {
    color: lightgreen;
}

RESULT

ID vs. parentID + child class

CODE

HTML

<div id="parent-id">
    <div class="child-class" id="child-id">The reason you are addicted to iPhone games is Amanda Wixted.</div>
</div>

#parent-id .child-class {
    color: purple;
}

#child-id {
    color: lightblue;
}

RESULT

parent ID + child class vs. parent ID + child ID

CODE

HTML

<div id="parent-id-1">
    <div class="child-class" id="child-id-1">Tracy Chou is the finest example of how good can females are at diverse programming needs.</div>
</div>

CSS

#parent-id-1 #child-id-1 {
    color: deeppink;
}

#parent-id-1 .child-class {
    color: purple;
}

RESULT

class with !important vs. parent ID + child ID

CODE

HTML

<div id="parent-id-2">
    <div class="important-class" id="child-id-2">
        Ada has the honor of being the first programmer in the world but other woman programmers are not far behind.
    </div>
</div>

CSS

.important-class {
    color: orange!important;
}
#parent-id-2 #child-id-2 {
    color: deeppink;
}

RESULT

class with !important vs. ID with !important

CODE

HTML

<div id="important-id" class="important-class">Programming is a fascinating career option in today’s world. It has mystery, glamor, and money provided you do hard work to achieve the best.
    However, it is a field dominated by males. Though, there are many female programmers who have made names for themselves.</div>
</body>

CSS

#important-id {
    color: yellow !important;
}
.important-class {
    color: orange !important;
}

RESULT

Based on the usage of CSS

CSS specificity based on where did we included our style is pretty straightforward:

• inline style is the strongest
• internal style beats included style
• if both styles are included the same way, the latter one prevails

Unless you have a good reason, I don't suggest you use inline or internal style. If you want to have your code clean and neat, always write your styling rules in separated CSS files. It's still good to know how this works.

We will compare CSS usages, listed bellow:

1. 2 included stylesheets
2. included stylesheet vs. internal style
3. internal style vs. inline style
4. inline style vs. ID
5. inline style vs. ID wih !important

2 included stylesheets

When both styles are included the same way, the latter one prevails. In this case, we use 2 external stylesheets. In the first one, we set the text color to 'green' and that gets overwritten by the second stylesheet, which sets the text color to 'blue'. As you can see in the image below, the text is blue. But in the first stylesheet, we also set a green, 2px wide border. In the second stylesheet, we do nothing to change that, so the border style from the first file is used.

CODE

HTML

<!DOCTYPE html>
<html lang="en">
<head>
    <link rel="stylesheet" href="style1.css">
    <link rel="stylesheet" href="style2.css">
</head>
<body>
<div class="included-style">
    Grace Murray Hopper was one of the first programmers of the Harvard Mark I computer. She invented the first compiler for a computer programming language and the one of those who popularized the idea of machine-independent programming languages.
</div>
</body>
</html>

style1.css

.included-style {
    color: green;
    border: solid green 2px;
}

style2.css

.included-style {
    color: blue;
}

RESULT

Included stylesheet vs. internal style

If we include a CSS file, we can easily overwrite its rules with the internal style, that is written in the <head> section of our HTML file. In the included stylesheet, we set the text to blue, but we overwrite this inside the <style> tags and we set it to red.

CODE

HTML

<!DOCTYPE html>
<html lang="en">
<head>
    <link rel="stylesheet" href="style1.css">
    <link rel="stylesheet" href="style2.css">

    <style>
        .included-vs-internal {
            color: red;
        }
    </style>
</head>
<body>

<div class="included-vs-internal">
    Lois Mitchell Habit was one of the ten-person team at IBM that developed FORTRAN, the first successful high-level programming language.
</div>

</body>
</html>

style2.css

.included-vs-internal {
    color: blue;
}

RESULT

internal style vs. inline style

The most powerful way to use some style is to write it inline. That means you write it directly on the element. The only way, you can overwrite that rule, is by !important. That means that inline style with added !important is impossible to overwrite. You should use inline styles with caution, otherwise, you can create a big mess.

Here we set the text color to red, but with an inline style, we changed it to orange.

CODE HTML

<!DOCTYPE html>
<html lang="en">
<head>
    <style>
        .internal-vs-inline {
            color: red;
        }
    </style>
</head>
<body>

<div class="internal-vs-inline" style="color: orange">
    Barbara Liskov (Born 7 Nov 1939) is one of the first women to be granted a doctorate in computer science in the United States and is a Turing Award winner who developed the Liskov substitution principle.
</div>
</body>
</html>

RESULT

Inline style vs. ID

Inline style is also able to overwrite the ID. If we set the text color to light blue with the ÌD selector and then add color: orange as an inline style, our text will be orange.

CODE HTML

<!DOCTYPE html>
<html lang="en">
<head>
    <style>
        #not-stonger-id {
            color: lightblue;
        }
    </style>
</head>
<body>
<div id="not-stonger-id" style="color: orange">
    Frances Elizabeth Allen was the first female IBM Fellow and in 2006 became the first woman to win the Turing Award.
</div>

</body>
</html>

RESULT

Inline style vs. !important

However, if add !important to the rule, written as internal CSS, that will prevail before the inline style.

Code is almost the same, we only added !important... :

CODE HTML

<!DOCTYPE html>
<html lang="en">
<head>
    <style>
        #not-stonger-id {
            color: lightblue !important;
        }
    </style>
</head>
<body>
<div id="not-stonger-id" style="color: orange">
    Frances Elizabeth Allen was the first female IBM Fellow and in 2006 became the first woman to win the Turing Award.
</div>

</body>
</html>

RESULT ...but as you can see, the result is different:

CONCLUSION

In this post, you got to knew the rules, by which CSS is applied and its specificity. That way, next time you'll be able to avoid adding !important when your CSS is not behaving as you expect it to. Not only that, you'll understand why it behaves the way it does and you'll be able to fix it.

The text used as a placeholder in the HTML was taken from: techworm and technotification

At the bottom, you'll find two exercises I derived from some psychotherapeutic exercise. They won't work miracles, but doing them in depth should help you improve your motivation and your planning ability.

We're prone to making easily achievable decisions faster and decisions we have to make an effort slower. So you want to make the wanted decisions easy to achieve and the decisions you don't want to make as hard as possible.

Limit the need for making good choices

Limit the time you spend making decisions. You can achieve that by erasing the choices that are the same every day ("I'm going to start to work now"). You achieve that by sticking to the routine. There are some choices, that can't be routine. They are different every time ("I'm going to work on that project"). You save yourself some time and nerves by planning ahead.

Routine

Maintain a weekly and daily routine. Some things will be the same every day (waking up, breaks, start and end of a workday)

Where a daily routine isn't possible or it doesn't make sense to do it every day, create a weekly routine.

Example of a weekly routine: Monday -> working on a blog Tuesday - Thursday -> current project Wednesday at 12.00 -> staff meeting Friday -> learning new things + longer lunch break

Many times we're given a false impression, that sticking to a routine will be effortless. Routine is weaker than a habit. That means sticking to a routine will still require some effort from you. Don't get discouraged by that, just stick to your routine.

Plan ahead

You have your routine down, but that's in general. You still need to know exactly what are you going to do in the days ahead. You know you'll write a blog on Monday, but what about? You'll work on your project on Tuesday, but which part? Have a plan in mind a week ahead (I'm having a meeting on Thursday, I'll push to production on Tuesday...). Just before you finish your work for today (not after that!), go through a plan for tomorrow.

If you'll sit down on your chair tomorrow and only then started thinking about what you're actually going to do, you'll lose so much energy. Worst case, you'll glide from one task to another and accomplish nothing.

Your plan has to be so clear that you can sit down in front of your computer and start right away.

Make unwanted choices harder to make

You start coding, decided to do a lot today, and after 7 minutes a notification pings. Either you'll check whatever notification or you'll keep wondering if it's something interesting. Either way, you lose focus.

You get to a though /boring task and you check social media, just for a second. Maybe you keep checking your emails in case it will be something important. You lose focus.

You make those decisions effortlessly. Maybe the tab is already open, the mobile phone is unlocked by the touch of your index finger... Make those decisions harder.

Leave your phone in another room (preferably upstairs). You're too lazy to go upstairs just for the sake of checking your notifications. Or turn it off. It takes forever for it to turn on, by then you'll already realize you're procrastinating.

Log out of social networks and mail clients. So used to already being logged in, you'll maybe open a Twitter page just to see you need to login and remember that that's not what you currently want.

If you have a basket of unfolded laundry in the same room, kick it out without hesitation.

If possible, don't work in the kitchen. A coffee maker and the fridge are way too close to you. Currently, the only place I can work in is our kitchen. I drink approximately 4 freshly brewed coups of tea per hour. I don't even want to count cookies.

Have a vision

It's hard to work for something if you don't know what that something is. You need to find something that drives you. If you work just for the sake of working, how will you continue when it won't be fun to work?

Why are you learning to code? Why are you learning this language? Why are you creating this program?

At the end of this post, you'll find two exercises that should help you create your vision. I strongly suggest you take the time and do them because good envisioning is sometimes the only thing that keeps you going.

Start your day with exercise

For me, a great way to start my day is going for a walk. Fresh air, simple movement, time to be with my thoughts. It is also a great time to envision my goals and plan ahead.

But it is very time-consuming and if you don't have the time for it, you can switch it for a light exercise. It will get your blood flowing and your body won't be nervous because of idleness.

There are many mobile apps that allow you to do full-body exercise in less than 10 minutes and that's a time you surely can spare. You can also do those exercises during your smart breaks.

Smart breaks

Planned. Regular. Well spent.

Don't take your break whenever you feel like it and however long as you want to. Let them be part of your routine. Know when you are taking them and how long they should be. Don't skip them.

One longer break in the mid of the day is not enough. The longer you go without break, the longer it will take you to get back to the start with your resources. There is no rule on how often and how long a break you need to take. Experiment a little, try to find out what works for you best.

Most of us probably spend our breaks scrolling Twitter/FB/news. This might surprise you, but that's a bad idea.

Stand up. Refill your water cup. Try to clear your mind of current coding problems. Stretch or do a short and light exercise. If you have time, go for a walk.

Don't sit and don't stare at a screen. That's what you've been doing before you took a break.

Keep it realistic

There are not enough motivation tools in the world to enable you to finish 47 tasks a day.

If you're setting you're expectations too high, you're setting yourself up for disappointment.

If your kids are in school/kindergarten from 9 AM to 3 PM, you can't work 9 hours. If you have a day job, you can't post a blog/long thread 5x/week. You can't learn a new framework in a week.

Expecting too much from yourself will make you only do less. Setting realistic goals and achieving them will make you motivated. Failing to meet your goals (almost) every time, will just make you question your ability.

Another side of being realistic is not having too low expectations. If you'll reach your goals without any effort, you'll get bored. If you'll reach your goals and nothing will change, you'll get frustrated.

Set good goals. Those two exercises can help you with that.

Motivation exercises

Here I'm presenting two exercises that are very similar in their execution. One is meant for you to go over your past accomplishments and the other is meant to create a vision, goals, and a plan to achieve them. Knowing where you came from and why are you doing what you're doing can be very motivational.

I advise you not to do both exercises at once. Take your time. It's not about drawing, it's about thinking.

For both exercises, you'll need a piece of paper and colored pencils.

River of coding's past

This exercise can help you appreciate what you already achieved. Too often we rush toward some goal and don't stop to 'smell the flowers'.

1. Draw a little circle on the left side of the paper for when you started your coding journey.

   Next to it, draw a symbol that represents your beginnings.

2. On the right side of the paper (on whatever height you want) draw a little circle for the present moment.

   Add a symbol that represents the current moment of your learning.

3. Draw a line between those two points that represent your journey until now.

   If your learning was steep, let the line represents that. If you quit for a while, dot the line. Draw the motivation drop and when you learned something huge.

4. Add symbols along the line for the important moments.

   When you felt that you learned CSS. When you started to learn Python or felt that you mastered JS. Whey you got your first job interview or landed your first job. When you had to take time off coding because you got a baby. Amazing things you created and all the projects you finished.

   Whatever feels important to you and is somehow related to coding. When you finish that, you should have a piece of paper that fairly represents your journey. It should show the troubles you overcome and the new knowledge you acquired.

5. Examine your journey and be proud of what you achieved.

   Try to remember that filling you got when you finished your first project. Try to experience again the excitement you felt when you got that job you wanted.

6. Put your index finger on the circle that represents NOW. Close your eyes.

   Imagine the time your learning will be over (in general; We never really stop learning). How will you know that you achieved your goal? What will be different for you? How will you feel like? What will it look like? What will you do when that time comes?

   This is a really important part of the exercise, so don't rush through it just hastily answering the questions I provided. Visualize it, put yourself in that moment.

River of coding's future

That exercise will help you envision your future as a developer. As explaining before, defining your goals is essential. Fantasizing about your vision and goals can get you through the rough patches.

1. On the right side of the paper draw the Ocean of Success. In the ocean, draw symbols for what you want to achieve.

   What programming languages you want to learn or be an expert at? Do you want to be your own boss? What is the paycheck you desire? What do you want that money for? Do you want to start a blog, do you want to achieve a certain number of followers/readers...

   Those are just suggestions, don't limit yourself to them.

2. On the left side of the paper, draw a water spring.

   That's where you are right now. You can add a symbol that represents you at a current moment.

3. Between the spring and the ocean draw a river any way you want to. Put symbols on the river for the important parts of your plan.

   If you want to land a FE job, you need to learn HTML/CSS/JS. If you want a promotion, you need to learn that framework... If you want to be your own boss you need to achieve financial stability and quit your day job. If you want to have a certain number of readers, you need to start a blog or be more regular at posting.

4. Put your finger on the spring and slowly follow the stream. Envision the path between you and your main goal.

   What do you have to do to get to the ocean? How are you going to get there? What will be the struggles you'll have to overcome? Try to really imagine it.

5. Put the paper somewhere near you. When you achieve something that is drawn on your river, color it, mark it.

   Be proud of yourself. You're getting closer to the ocean...

Conclusion

Motivation doesn't just fall from the sky. Highly motivated people weren't born with it. They worked for it.

If you feel unmotivated for some time, come back to those exercises. See if your goals have changed. It's hard to pursue goals we no longer wish for.

Maybe your routine is not working for you anymore. Or maybe you're just tired.

Don't judge yourself if you feel unmotivated, even though you're trying sooo hard.

Sometimes we all need just a little rest.

Images are from Unsplash. Creators: Drew Beamer, Dad hotel, Randy Tarampi.

• While you can change its type, you can't change the color.
• You can select the position of the bullet in two ways (inside/outside), but you don't have any influence regarding pixels.
• You can use an image, but you can't resize or change its position in any way.

If you want to have a lot of freedom at styling it, you have to hide the default list-style and create new 'bullets' with ::before.

What will I learn?

In this tutorial, we will review 5 possibilities of styling bullets:

1. Squares
2. Triangles
3. Icons
4. Images
5. Bullets that differs

Prerequisites

• basic HTML
• basic CSS
• pseudo-selector ::before

If you don't feel comfortable with ::before, I suggest you check this post explaining it thoroughly.

Intro

All the lists are going to be unordered lists. There will be five of them, each with a different class ('square-bullets', 'arrow-bullets', 'icon-bullets', 'image-bullets' and 'different-bullets'). Each ul will be created in its own HTML file (named the same as the class of our ul) and each we'll create CSS for it in a separated .css file with the same name. In all the CSS we'll include a part that sets list-style to none, so the out-of-the-box list styling doesn't interfere with our creations. Also for all the bullets will set some padding (ul > li {padding: 10px 25px}) so our bullets have a little breathing room.

Squares

Square bullets can be very useful when you want to associate each <li> element with a differently colored area. You can create squares of different colors (we will see how to that on the last ul).