Frameworks exist to save you from having to re-invent the wheel and help alleviate some of the overhead when you’re building a new site.

To understand what Django actually is for, we need a closer look at the servers. First thing is that the server needs to know that you want it to serve you a webpage.

Imagine a mailbox (port) which is monitored for incoming letters (requests). It is done by a web server. The web server also sends a response with a webpage. But when you want to send something, you need to have some content. And Django is something that helps you create the content.

When a request comes to a web server it's passed to Django which tries to figure out what actually is requested. It takes a webpage address first and tries to figure out what to do. This part is done by Django's urlresolver (Note that a website address is called URL - Uniform Resource Locator, so the name *urlresolver* makes sense). It is not very smart - it takes a list of patterns and tries to match the URL. Django checks patterns from top to the bottom and if something is matched then Django passes the request to the associated function (which is called *view*).

Of course, the description above is a little bit simplified, but you don't need to know all the technical things yet. Knowing a general idea is enough.

We made a picture for you! It looks like this:

Looks like a mess, right? But in fact it is a network of connected machines (*servers*). Hundreds of thousands of machines! Many, many kilometers of cables around the world! You can visit a Submarine Cable Map website (http://submarinecablemap.com/) to see how complicated the net is. Here is a screenshot from the website:

So basically, when you have a website you need to have a *server* (machine) on which it is. The *server* is waiting for any incoming *requests* (letters that ask you to send your website) and it sends back your website (in another letter).

Let's start with something really simple. For example, try typing some math, like `2+3` and hit Enter.

You just used the `upper` __method__ on your string! A method (`upper`) is a set of instructions that Python has to perform on a given object (`"Ola"`) once you call it.

If you want to get the number of letters in your name, there is a method for that too!

Wonder why sometimes you call methods by adding `.` at the end of the string (like `"Ola".upper()`) and sometimes you first call a method and place the string in parentheses? Well, in some cases, methods belong to objects, like `upper` that can only be performed on Strings. But sometimes, methods don't belong to anything specific and can be used on different types of objects, just like `len`. That's why we're giving `"Ola"` as a parameter to `len` method.

- __methods__ - are actions in Python. You've used both English-language methods (upper, len) and symbolic ones (+, *).

That's the basic of every programming language you learn. Ready for something harder? We bet you are!

It worked! We used `str` method inside of `len` method. `str` is converting everything to strings.

- `str` method convert things into __strings__

- `int` method convert things into __integers__

There is a concept in programming called variables. A variable is nothing more than a name for something so you can use it easier. Programmers use these variables to store data, make their code more readable and to not forget what something is.

Yikes! Your first variable :)! You can always change what it is:

You can use it in methods too:

Beside strings and integers, Python has all sorts of different types of objects. Now we're going to introduce one called __list__. List is the exact thing you think about now: object that is a list of objects :)

All right, we have a list! What can we do with it? Let's see how many lottery numbers there are in a list. Do you have an idea which method you should use for that? You know this already!

This doesn't return anything... because we didn't print it! Try this:

If you want to read only the first number, you can do this by using index. The first object of the list is an object number 0, next one is 1, and so on. Try this:

As you can see, you can access different objects in your list by using its name and index number inside of brackets.

Accidently, you just learned about a new type of object in Python. It's __boolean__ -- probably the easiest type there is.

Boolean can be only two things:

- __boolean__ - type of object that can only held two values: `True` and `False`

- __if...elif...else__ - statements that are helpful to execute only code that meet given conditions.

Remember about methods like `len` that you can execute in Python? Well, good news, you will learn how to write your own functions now!

As you can see, there are the dots again! This means that nothing has really happenned yet... and yes, we need to do a `TAB` before giving our instructions:

Congratulations! You just learned how to write functions :)!

`range` is a method that creates a list of numbers from one number to another (numbers are given by you as parameters).