• Django – High-Level Python web framework that encourages
rapid development and clean pragmatic design.
• It helps the developers to build web applications providing
them with pre-built components for common tasks like
authentication, URL routing, database management, and
template rendering.
• It understands the MVT (Model View Template) architecture
plan.
Explanation of each Python File in a Django Project and Application.
1. manage.py:
• This is a command-line utility file for interacting with your
Django project.
• It is used for tasks like running the development server,
managing the database migrations, and executing various
Django commands.
2. settings.py:
• This file contains the configuration settings for your
Django project.
• You can define things like database settings, middleware,
installed apps, static files configuration, and many more.
3. urls.py:
• This file maps URL patterns to views in your Django
project.
• You define URL patterns using regular expressions and link
them to corresponding view functions.
4. Wsgi.py:
• Stands for Web Server Gateway Interface.
• It is used to help Django communicate with web servers
like Apache or Nginx.
• Generally, you don’t need to modify this.
5. Init.py:
• This file is used to mark the directory as a Python Package.
• It is typically left empty.
For each application within the Django Project
1. Models.py:
• This is where you define your database models using
Django’s ORM (Object Relational Mapping) System.
• You define Python classes that represent database tables
and their fields.
2. Views.py:
• Views are Python functions that handles the HTTP request
and return the HTTP Responses.
• This file contains the view functions for your application.
3. Urls.py (optional for applications):
• Similar to the project’s urls.py, this defines URL patterns
specific to a application.
• Helps in organizing and managing the URL’s within the
application.
4. Admin.py: (Optional)
• This file allows you to register your models within the
Django admin interface.
• You can customize how your models are displayed and
managed in the admin interface.
5. Apps.py:
• Configuration file for the application.
• Allows you to define the application-specific
configuration.
• This is often not modified unless needed.
6. Init.py:
• This is similar to the project’s init.py. It is used to mark the
directory as a Python package.
• It is usually kept empty.
Purpose of frequent commands:
1. runserver:
• Startsup the Django’s development server, allowing you to
test your Django project locally during development.
• It is used by the server of your Django application so that
you can access it via a web browser.
• By default, the development server runs on the port 8000
• Ex: python manage.py runserver
2. Migrate:
• This migrate command is used to apply database
migrations to synchronize the database schema with the
current state of your Django models.
• When you define or modify the models in Django, you
create migration files that specify the changes to be made
to the database schema.
• Running the python manage.py migrate applies these
migration files, creating or modifying the database tables
accordingly.
3. createsuperuser:
• This command is used to create a super user account for
accessing the Django admin interface.
• Superusers have the full access to the data and
functionality within the Django admin.
• When you run python manage.py createsuperuser, Django
will prompt you to enter a username, email address, and
password for the new-superuser account.
• This command is particularly useful for setting up
administrative access to manage your application’s data
during the development or in production environments.
Major differences between the GET method and POST method in
Django:
GET:
• Parameters are visible in the URL.
• Suitable for retrieving the data from the server.
• Generally used for non-sensitive data.
• Limited.
• Considered idempotent, meaning repeating the same request
multiple times should have the same effect as making it once.
POST:
• Parameters are not visible in the URL.
• Suitable for submitting the data to the server.
• Used for sensitive data or when modifying the server-side data.
• Can handle larger amounts of data compared to the GET.
• Not inherently idempotent, as repeating a POST request may
result in multiple actions being performed on the server.
