# Getting Started with Django

In the expansive fields of web development frameworks, Django stands out as a powerful and favored option for creating robust web applications. As an open-source Python web framework, Django was specifically designed to simplify the web development process while adhering to the principle of **"don't repeat yourself" (DRY)**. Its focus on efficiency, scalability, and security has captured the hearts of developers worldwide.

# Features

Django boasts an array of distinctive features that set it apart:

1. **Scalability**: The modern world demands web applications that can handle an ever-increasing number of users and data. Django's scalability is a result of its ability to efficiently manage database queries, handle caching, and optimize code execution. This scalability makes Django suitable for applications ranging from small startups to large-scale enterprises.
    
2. **Security**: Security is of paramount importance in the modern digital landscape, and Django takes security seriously. It comes with built-in features to prevent common web vulnerabilities like SQL injection, cross-site scripting (XSS), and cross-site request forgery (CSRF). Additionally, Django's authentication system allows for secure user management.
    
3. **Versatility**: Django's versatility is evident in its ability to support various types of web applications. Whether it's a content-heavy website, an e-commerce platform, a social media network, or an API-centric application, Django can handle diverse requirements.
    
4. **Community and Documentation**: Django boasts an active and robust community of developers, contributing to its constant growth and improvement. The official documentation is extensive, well-maintained, and beginner-friendly, making it easier for developers to learn and utilize the framework effectively.
    
5. **Django REST Framework**: In the modern world of web development, APIs (Application Programming Interfaces) play a vital role in enabling seamless interactions between different services and platforms. Django's integration with the Django REST Framework simplifies the process of building powerful and scalable Web APIs.
    

# Setting Up a Django Project

### Creating a Virtual Environment

A virtual environment allows you to create an isolated Python environment for your project, ensuring that the dependencies you install don't interfere with other projects on your system.

```bash
# On Windows
python -m venv project_env

# On macOS and Linux
python3 -m venv project_env
```

This will create a new directory called `project_env` containing the virtual environment.

> To activate virtual environment in your project run `project_env\Scripts\activate` on Windows or `source project_env/bin/activate` on Mac OS X or Linux will activate your virtual environment.

Now that the virtual environment is set up, it's time to install Django. Within your virtual environment, use pip to install Django:

```bash
# On Windows, macOS, and Linux
(project_env) ~/pip install django
```

### **Creating the Django Project**

With Django installed, you can create a new Django project. Navigate to the folder where you want to create your project, and run the following command:

```bash
(project_env) ~/django-admin startproject myproject
```

This will create a new directory named `myproject`, which will be the root of your Django project.Inside the `myproject` directory, you'll find the initial folder structure of your Django project:

```bash
myproject/
|-- manage.py
|-- myproject/
    |-- __init__.py
    |-- asgi.py
    |-- settings.py
    |-- urls.py
    |-- wsgi.py
```

1. [`manage.py`](http://manage.py) file is a command-line utility that allows you to interact with your project.
    
2. [`settings.py`](http://settings.py) file contains the configuration of your website.
    
3. [`asgi.py`](http://asgi.py) configures the application to handle asynchronous web servers using the ASGI (Asynchronous Server Gateway Interface) specification.
    
4. [`wsgi.py`](http://wsgi.py) configures the application to work with traditional synchronous web servers using the WSGI (Web Server Gateway Interface) standard.
    

> Django provides a pre-built and pre-configured development server that you can easily run using the command `python` [`manage.py`](http://manage.py) `runserver`. When you navigate to the locally deployed Django address, typically at [http://127.0.0.1:8000](http://127.0.0.1:8000/).

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1689938515440/88997aa8-3d64-44ba-95d0-4b61de835577.png align="center")

> You have successfully run your Django first application.But you may be curious to see some custom output by your own.Let's do that.

### Creating Django apps

In Django, a web application is typically divided into smaller components called "apps." Each app handles a specific functionality or set of related features within the overall project.

To create a new app, navigate to the root directory of your Django project using the terminal (where the [`manage.py`](http://manage.py) file is located) and run the following command:

```bash
python manage.py startapp <app_name>
#For example 
(project_env) ~/python manage.py startapp hello_app
```

This command will create a new directory named `hello_app`, which contains the initial structure of the app:

```python
hello_app/
|-- migrations/
|   |-- __init__.py
|-- __init__.py
|-- admin.py
|-- apps.py
|-- models.py
|-- tests.py
|-- views.py
```

**This will create another directory called hello\_app with several files:**

* `__init__.py` tells Python to treat the directory as a Python package.
    
* [`admin.py`](http://admin.py) contains settings for the Django admin pages.
    
* [`apps.py`](http://apps.py) contains settings for the application configuration.
    
* [`models.py`](http://models.py) contains a series of classes that Django’s ORM converts to database tables.
    
* [`tests.py`](http://tests.py) contains test classes.
    
* [`views.py`](http://views.py) contains functions and classes that handle what data is displayed in the HTML templates.
    

### Including the App in Settings

After creating the app, you need to include it in the project's settings. Open the [`settings.py`](http://settings.py) file inside the `myproject` directory and locate the `INSTALLED_APPS` list. Add your app name (hello\_app) to the list:

```python
INSTALLED_APPS = [
    # ...
    'hello_app',
    # ...
]
```

> By adding your app to the `INSTALLED_APPS` list, Django recognizes the app and includes it in the project.

### Writing the "Hello, World!" View

In Django, views handle the logic for processing HTTP requests and returning responses. Let's create a simple "Hello, World!" view inside the [`views.py`](http://views.py) file of the hello\_app:

```python
# hello_app/views.py
from django.http import HttpResponse

def hello_world(request):
    html_content = "<h1>Hello, World!</h1>"
    return HttpResponse(html_content)
```

### Creating a URL Mapping

Now that we have our view defined, we need to map it to a URL. Open the [`urls.py`](http://urls.py) file inside the `hello_app` directory and add the following code:

```python
# hello_app/urls.py

from django.urls import path
from . import views

urlpatterns = [
    path('hello/', views.hello_world, name='hello_app'),
]
```

> In this code, we import the `hello_world` view we created and map it to the URL path `/hello/`.

### Include the App URLs in the Project

To make the app's URLs accessible within the project, open the [`urls.py`](http://urls.py) file of the project (located in the `myproject` directory) and include the app's URLs using the `include` function:

```python
# myproject/urls.py

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('hello_app/', include('hello_app.urls')),  # Include the app's URLs
]
```

> Now, when you access `127.0.0.1:8000/hello_app/hello/` .You will see below output:

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1689938132085/a24228e1-97d4-48a1-98bc-1e16290bf8c7.png align="center")

> Congratulations! You've successfully set up a Django project from scratch. Now you can start building your web application using Django's powerful features and elegant design.