What are model relationships in Django for?


Relationships between people are complicated; what about between models?

It can seem easy in theory... up to the point when you have to develop your first real app which needs to set up relationships (also know as associations) between models.

As usual, my explanation is going to involve cats.
Lots of them.
So brace yourself.

_This post assumes understanding of Django models.
If you don't know much about them, read [the other post of mine](/blog/django-models)._

### One cat, one owner

Imagine this: Mike has a cat named Luna.

<img style="max-width: 320px;" src="/post-img/models_relationships/1.png">

Mike **has only one cat**, Luna, and Luna **has only one owner**, Mike.
Such relationships are called **one-to-one**.

How can we implement it in code?

<img style="max-width: 600px;" src="/post-img/models_relationships/2.png">

In database it will look like this:

<img style="max-width: 600px;" src="/post-img/models_relationships/3.png">

Luna has the same `id` as their owner (and no `id` of its own)

Here's how you would create a cat for a person:

```python
owner = ...
cat = Cat(owner = owner, name = 'Luna')
cat.save()
```

And here's how you would get the cat for the person:

```python
owner = ...
owner.cat
```

And the owner of the cat:

```python
cat = ...
cat.owner
```

Other examples of one-to-one:

- a user has only one profile;
- a country has only one capital.

### Many cats, one owner

Let's look another example.
People can **have a lot of cats**.

<img style="max-width: 450px;" src="/post-img/models_relationships/4.png">

Eva has three cats: Luna, Jasper, and Max.
The relationship between Eva and their cats is called **many-to-one** or **one-to-many**.

In code:

<img style="max-width: 600px;" src="/post-img/models_relationships/5.png">

And in database:

<img style="max-width: 600px;" src="/post-img/models_relationships/6.png">

You can now create as many cats for a particular person as you want:

```python
owner = ...
owner.cat_set.create(name = 'Luna')
owner.cat_set.create(name = 'Jasper')
owner.cat_set.create(name = 'Max')
```

To get all the cats for a person, you'd do:

```python
owner = ...
owner.cat_set.all()
# gives us a list of cat objects:
# [<Cat Luna>, <Cat Jasper>, <Cat Max>]
```

And to get the owner of a particular cat:

```python
cat = ...
cat.owner
```

Other examples of many-to-one:

- a user can upload many pictures;
- a person can have multiple bank accounts;
- a product listing can have several reviews;
- an author can have several articles.

### Many cats, many owners

Earth has finally embraced polyamory and shit.

<img style="max-width: 450px;" src="/post-img/models_relationships/7.png">

So now one cat **has many owners** and one owner **has many cats**.
Here we have three owners: Eva, Alex and Mike.
Eva has Max and Luna; Alex – Max, Luna, and Jasper; Mike – Tigger and Max.
You can notice that Max has three owners: Eva, Alex, and Mike.

<img style="max-width: 600px;" src="/post-img/models_relationships/8.png">

In database:

<img style="max-width: 600px;" src="/post-img/models_relationships/9.png">

Pay attention to extra orange table which will be created automatically. This extra table creates relationships between models.

So how do we create such polyamory relationships?

First of all we should create cats and owners like this:

```python
owner = Owner(name = 'Eva')
owner.save()
...

cat = Cat(name = 'Max')
cat.save()
...
```

The immoral polyamory emerges:

```python
owner.cats.add(cat)
```

And here's how we can inspect this relationship by listing all owners of a cat, or all cats of a particular owner:

```python
owner.cats.all() # [cat]
cat.owners.all() # [owner]
```

Other examples of many-to-many:

- a virtual basket can contain many products, and a product can be in multiple baskets;
- a person can have accounts at many banks, and a bank can have many clients;
- a book can be written by many authors, and an author can write many books;

**See also:**

- [The simple way to understand Django models](/blog/django-models)
- [From URL to web page: walk through to Django](/blog/from-url-to-webpage)


The simple way to understand Django models


If you ever tried to learn models by going through Django Docs, did you leave with answers, or with even more questions?

Personally, I started doubting whether programming is really for me.

<img style="max-width: 300px;" src="https://media.giphy.com/media/Nm8ZPAGOwZUQM/giphy.gif">

I wrote this post to help you understand Django models and basic operations with them.

Models are an excellent method to work with data!

Say we want to keep track of our amazing cats.
We would create a `Cat` model, but what is a model anyway?

Turns out, a model is kinda three things in one:

<img style="max-width: 700px;" src="/post-img/django_models/1.png">

Now, let's walk through each block.

## Table with cats in database

<img style="max-width: 500px;" src="/post-img/django_models/2.png">

We create a class (= a model) named `Cat`.

When we add columns we must tell Django which kind of data will be in each of them.
That can be string, digits, boolean etc.

So, a cat's name should be a text — it's a `CharField` in Django (don't forget to set the maximum length for this field, because the database needs to know it).
A cat's weight in grams is an integer — so we use an `IntegerField`.

Finally, `null` makes it possible to leave a column blank.
For example, if we don't know the weight.
Note that any field can be marked as `null`.

As an aside: the `id` column is generated automatically.

A finishing touch is to propagate changes (like creating a model, adding a column etc.) into our database schema.
For that we use `python manage.py makemigrations` and then `python manage.py migrate`.
It's important to do it every time you change something in the models.

Now we have a table but we don't have anything inside it.
Let's fix it.

## Operations with all cats

### Creating a new one

<img style="max-width: 500px;" src="/post-img/django_models/3.png">

`create()` function helps us to create some rows.
We just need to pass all the purry details into it.

### Finding a particular one

<img style="max-width: 500px;" src="/post-img/django_models/4.png">

If you want to get cat's <strike>FBI file</strike> meow-xcuse me, the cat's info; then we can just use the `get()` function with one of the cat parameters.
In the example, I use `pk` which means "primary key".
Most often, that would be the same as using `id`.

`get()` will find all rows matching the parameters and only return the first one.

### Finding all the records

<img style="max-width: 500px;" src="/post-img/django_models/5.png">

On top of that, you can access all cats from the database by using the `all()` function.

### Filtering out

<img style="max-width: 500px;" src="/post-img/django_models/6.png">

Or do you need cats lighter than 3000 g?

A function named `filter` is ready to help us with that.

We pass `field__lookuptype = 'value'` into it to filter out the cats.

In the example, `lt` means "less than".
So `weight_g__lt=3000` means "weight is less than 3000 g".

## Operations with one cat

### Updating

<img style="max-width: 500px;" src="/post-img/django_models/7.png">

Last time we weighed Luna, she was 3200 g.
But now her weight is 3100 g.
It's very easy to change that.

We just get Luna from the database by her name, and then change her weight to 3100.
It's that simple.
Just one thing — we have to call `.save()` when we're done changing.

### Deleting, like, forever

<img style="max-width: 500px;" src="/post-img/django_models/8.png">

We can delete one of our cats.
Very sad.
But that's life.

We get _the_ cat and call the `.delete()` function.

**See also:**

- [What the curly hell do you pass into \`render\`?](/blog/curlu-hell-render)
- [From URL to web page: walk through to Django](/blog/from-url-to-webpage)


From URL to web page: walk through to Django


Understanding is one of the most important things when learning to code.
And it's not the easiest — sometimes you just want to bang your head against the wall.
That's what happened to me when I started to learn Django.

Here I want to show you what `urls.py` and `views.py` are for, and how they help a simple URL to become a full web page.

Let's figure it out:

<img style="max-width: 700px;" src="/post-img/from_url_to_webpage/1.png">

Say we open **https://cats.com/cats/** in our browser.

First thing, Django drops the domain from the URL and we are left with **cats/**.
Then Django goes through the URL patterns in `urls.py` (aka the URL rule list) in an attempt to find a rule that would match.

And it finds one.
It's a rule with `name='cats'`.

According to this rule, Django knows which view must be used to handle a request - it's `views.show_all_cats`.

Django calls the `show_all_cats` function (which comes from `views.py`).
Which in turn renders the `cats.html` template.

(For more details about the dictionary in the `render` function, see [What the curly hell do you pass into \`render\`?](/blog/curlu-hell-render))

And finally, we are full of love for the beautiful purr-y creatures.

![](https://media.giphy.com/media/ExMGjbktr4phe/giphy.gif)

**See also:**

- [The simple way to understand Django models](/blog/django-models)


What the curly hell do you pass into `render`?


Back when I started to learn Django, everything seemed so tough.
As the time went and I kept practicing, many things started to make sense to me.
But there was one thing in particular that felt alien...

How the `render` function and the context dictionary that you pass into it play together.

I realize I'm probably not the only one experiencing this problem.
So here's a simple mental model that I came to, which made everything click:

<img style="max-width: 700px;" src="/post-img/curlu-hell-render/1.png">

The first one, `index.html`, is the most obvious.
It specifies the name of the HTML template to be rendered.
No questions here.

But what if we need the template to use some variable that we have in the view?

There's the context dictionary for that.
It's simple, really.

The key in the dictionary, `kitty`, will be the name of the variable that we can use in the template.

The value for that key, `cat`, is the name of this variable in the function.

By writing `{'kitty': cat}`, we are basically saying this:

When the template makes use of the `kitty` variable (like {% raw %}`{{ kitty }}`{% endraw %}), use the value of the `cat` variable from the view.

Following the depicted example, {% raw %}`{{ kitty }}`{% endraw %} will be shown as `Murzik` — because that's what the `cat` variable holds.

**See also:**

- [From url to web page: walk through to Django?](/blog/from-url-to-webpage)
- [The simple way to understand Django models](/blog/django-models)


Python/Django