What is django?
Tags: django, python, database
Published: 2023-04-15 17:47:59

Django is a high-level Python web framework that enables the rapid development of secure and maintainable websites and web applications. It follows the Model-View-Controller (MVC) architectural pattern, but with some variations, such as using the Model-View-Template (MVT) pattern instead.

Django provides a robust set of tools and libraries for handling common web development tasks, such as handling forms, authentication, routing, database migrations, and more. It also emphasizes the concept of "batteries included", which means that it includes many useful features out of the box, so developers don't have to spend time building everything from scratch.

Django is a popular choice for web development due to its simplicity, scalability, and versatility. It is used by many companies and organizations, including Instagram, Spotify, Mozilla, and The Washington Post, among others.

So, Lets Dive In 🏊...!
<img width="100%" style="width:100%" src="https://media.giphy.com/media/f6z5TkrTIBZILYOd1t/giphy.gif">

## Creating a Virtual Environment in Windows
![windows](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nq7pqeuxkvj4czzmq1jm.png)
1. Open the command prompt by pressing the `Windows key + R` and then typing `cmd` in the Run dialog box.
2. Navigate to the directory where you want to create your virtual environment using the `cd` command. For example, to navigate to the desktop, you can type `cd Desktop`.
3. Once you're in the desired directory, enter the command `python -m venv myenv` to create a virtual environment named `myenv`. You can choose any name for your virtual environment.
4. Activate the virtual environment by entering the command `source myenv\Scripts\activate`. You should see the name of your virtual environment appear in parentheses in the command prompt.

## Creating a Virtual Environment in Mac/Linux
![mac/linux](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/c1khy5b582xylyrprvpw.png)

1. Open the terminal by pressing `Command + Spacebar` and then typing `terminal` in the Spotlight Search bar.
2. Navigate to the directory where you want to create your virtual environment using the `cd` command. For example, to navigate to the desktop, you can type `cd Desktop`.
3. Once you're in the desired directory, enter the command `python3 -m venv myenv` to create a virtual environment named `myenv`. You can choose any name for your virtual environment.
4. Activate the virtual environment by entering the command `source myenv/bin/activate`. You should see the name of your virtual environment appear in parentheses in the terminal.

That's it! You have successfully created a virtual environment in both Windows and Mac/Linux. Now you can install any packages or dependencies required for your project within the virtual environment without affecting the system-wide Python installation.

## Installing Django
1. Open a command prompt or terminal window.
2. Check if Python is already installed on your system by running the command `python --version`. If Python is not installed, download and install Python from the official website.
3. Once Python is installed, run the command pip install django to install Django.
4. Wait for the installation to complete. This might take a few minutes depending on your internet connection speed.
5. Once the installation is complete, verify the installation by running the command `django-admin --version`. This should output the version number of Django installed on your system.

Congratulations! You have successfully installed Django on your local machine. You can now start building your web applications using the Django web framework.

<img width="100%" style="width:100%" src="https://media.giphy.com/media/qx8pi39Lwm9Xm2audb/giphy.gif">

## How to Create a New Django Project.
1. Open your terminal or command prompt.
2. Navigate to the directory where you have created virtual environment and make sure your virtual environment is activated.
3. Run the following command to create a new Django project:
    ```bash
django-admin startproject project_name
```
    Replace `project_name` with the name you want to give your project.
4. Once the project is created, navigate to the project directory using the following command:
    ```bash
cd project_name
```
    Again, replace `project_name` with the name of your project.
5. To test that your project has been created successfully, run the following command:
    ```bash
python manage.py runserver
```
    This will start the development server. You should be able to see the Django welcome page by navigating to `http://localhost:8000/` in your web browser.

That's it! You've successfully created a new Django project.

## How to create Django App
1. Open a terminal or command prompt.
2. Navigate to the root directory of your Django project (the folder where `manage.py` is present).
3. Run the following command:
    ```bash
python manage.py startapp <app_name>
```
    Replace `<app_name>` with the name of your app. For example, if you want to create an app called `blog`, you would run:
    ```bash
python manage.py startapp blog
```
4. Django will create a new directory with the name you provided for the app. The directory will contain several files and subdirectories.
5. Open the `settings.py` file in your Django project folder and add the name of your app to the `INSTALLED_APPS` list. For example:
    ```python
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'blog', # Add your app name here
]
```
6. Save the `settings.py` file.
7. You're now ready to start building your Django app!
8. Now run `python manage.py migrate` command to apply any pending database migrations to the database schema.

## Now let's understand Django App file structure
```markdown
project_name/
├── app_name/
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── models.py
│   ├── tests.py
│   └── views.py
├── project_name/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py
```
Let's break it down:
1. `project_name/` - This is the root directory of the Django project.
2. `app_name/` - This is a directory that contains a single Django app. You can have multiple apps within a single Django project.
3. `__init__.py` - This is an empty file that tells Python that this directory should be considered a Python package.
4. `admin.py` - This file is used to register models with the Django admin site.
5. `apps.py` - This file is used to configure the Django app.
6. `models.py` - This file contains the database models for the Django app.
7. `tests.py` - This file contains the test cases for the Django app.
8. `views.py` - This file contains the view functions for the Django app.
9. `settings.py` - This file contains the settings for the Django - project, such as database configuration and installed apps.
10. `urls.py` - This file contains the URL routing configuration for the Django project.
11. `wsgi.py` - This file is used for deployment to WSGI-compatible servers.
12. `manage.py` - This file is used to run management commands for the Django project.

## Settings for static, media files
1. Set up media and static file directories
First, create two directories named "media" and "static" in your project directory to store your media and static files, respectively. To do this, simply create two folders in the root directory of your project.

2. Update the project settings file
In your project settings file, add the following lines of code to specify the directories where your static and media files will be stored:
    ```python
    MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
    MEDIA_URL = '/media/'

    STATIC_ROOT = os.path.join(BASE_DIR, 'static')
    STATIC_URL = '/static/'
    ```

    Here, `MEDIA_ROOT` and `STATIC_ROOT` are the directories where Django will look for your media and static files, respectively. `MEDIA_URL` and `STATIC_URL` are the URLs that will be used to access your media and static files.


3. Update your project's URLs file
In your project's `urls.py` file, add the following code to serve the static and media files:
    ```python
    from django.contrib import admin
    from django.urls import path, include
    from django.conf import settings
    from django.conf.urls.static import static

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

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

- Here, `DEBUG` is a Boolean value in your settings file that determines whether your application is running in debug mode or not. If it is set to `True`, then the `static()` and `media()` functions will serve your media and static files, respectively.

- Now, you can access your media and static files using the URLs you specified in the `MEDIA_URL` and `STATIC_URL` settings.

After following above steps your django file structure should look something like this.
```markdown
project_name/
├── app_name/
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── models.py
│   ├── tests.py
│   ├── views.py
│   └── static/
├── project_name/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   ├── wsgi.py
│   └── static/
└── manage.py
```

## App and Project urls connection
- In your app's directory, create a file named `urls.py`. This file will contain all of the URLs for your app.
- In the `urls.py` file of your app, import the Django `path` function and any views that you want to associate with specific URLs.
```python
from django.urls import path
from . import views
```
- Define your app's URLs using the `path` function. This function takes two arguments: the URL pattern and the view function that should handle the request.
```python
urlpatterns = [
    path('home/', views.home, name='home'),
    path('contact/', views.contact, name='contact'),
]
```
In this example, we've defined two URLs for our app: /home/ and /contact/. The first argument of the path function specifies the URL pattern, and the second argument is the view function that should handle the request. We've also given each URL a name using the name argument. This is useful when generating URLs in templates or views.
- In your project's main `urls.py` file, import the `include` function from Django's `urls` module, as well as the `urls.py` file of your app.
```python
from django.urls import include, path
from myapp import urls as myapp_urls
```
Here, we're assuming that our app is named `myapp`.
- In the `urlpatterns` list of your project's `urls.py` file, add a `path` function for your app's URLs, using the `include` function to include your app's `urls.py` file.
```python
urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include(myapp_urls)),
]
```
In this example, we've added a `path` function for our app's URLs using the `include` function. The empty string `''` specifies that our app's URLs should be included at the root URL of our project.

Overall, this directory structure provides a clear separation of concerns between the project-level and app-level components of a Django application. Understanding this structure is key to building scalable and maintainable Django projects.

<img width="100%" style="width:100%" src="https://media.giphy.com/media/l0Iyl55kTeh71nTXy/giphy.gif">