PYTHON-DJANGO

Internship Report

Submitted to
KARPAGAM ACADEMY OF HIGHER EDUCATION

in partial fulfilment of the requirements for the award of the degree of

BACHELOR OF SCIENCE IN COMPUTER SCIENCE

Submitted by
SRI RAJA RAJESWARI
(23CSU049)

Department of Computer Science

KARPAGAM ACADEMY OF HIGHER EDUCATION

(Deemed to be University)
(Established Under Section 3 of UGC Act, 1956)
(Accredited with A+ Grade by NAAC in the Second Cycle)
Pollachi Main Road, Eachanari Post,
Coimbatore – 641 021.
OCTOBER 2024
 KARPAGAM ACADEMY OF HIGHER EDUCATION
(Deemed to be University)
(Established Under Section 3 of UGC Act, 1956)
(Accredited with A+ Grade by NAAC in the Second Cycle)
Pollachi Main Road, Eachanari Post,
Coimbatore – 641 021.

BACHELOR OF SCIENCE IN COMPUTER SCIENCE

BONAFIDE CERTIFICATE

This is to certify that the Internship work entitled “PYTHON-DJANGO” is done by SRI

RAJA RAJESWARI R (23CSU049), during the period September 2nd, 2024to October

1st,2024in partial fulfilment of the Degree of B.Sc. Computer Science.

Internal Examiner Head of the Department

 DECLARATION
I, hereby declare that the Internship entitled “PYTHON-DJANGO” submitted for the B.Sc.
Computer Science Degree is my original work.

Place: Coimbatore

Date: Signature of the Student

(SRI RAJA RAJESWARI)
Attach Company Certificate - Original
 ABSTRACT

I am delighted to present an abstract summarizing my completion of

the Full Stack development in Python internship, showcasing the
valuable experiences, skills gained and achievements accomplished
throughout the program. This abstract is intended to provide a
comprehensive overview of my internship journey to share with the
college administration. I have acquired hands-on experience in
developing web pages, strengthening my programming skills and technical
proficiency. The internship has familiarized me with industry- standard tools,
practices, and workflows, making me well-prepared to embark on a
professional career in website development. Working in a team environment
has improved my collaboration, communication and adaptability skills,
enabling me to effectively contribute to group projects. The internship
challenged me to overcome complex programming problems, fostering my
analytical thinking and enhancing my problem-solving capabilities. Engaging
with experienced mentors and industry professionals has broadened my
horizons, allowing me to gain insights into the industry and develop a
growth minds.
 TABLE OF CONTENTS

S.No Index

1 Introduction

About the project

2.1 Module Description
2
2.2 Input/Output Design
2.3 Reports

3 Conclusion
 1. INTRODUCTION

Student Management System (SMS) is a comprehensive software application

designed to streamline various administrative tasks within educational
institutions, including student data management , attendance tracking, grade
reporting, and fee collection, It facilitates effective communication between
teachers, students, and parents, while also managing course schedules,
examinations, library resources, and even hostel and transportation services.
The system improves operational efficiency by automating processes like
admission, timetable scheduling, and financial management, while providing
valuable insights through Analytics and reporting tools. Additionally SMS
ensures data security and privacy, offering mobile access for real-time updates
and engagement.

PYTHON:

Python is an interpreted, object-oriented, high-level programming language with

dynamic semantics. Its high-level built in data structures, combined with
dynamic typing and dynamic binding, make it very attractive for Rapid
Application Development, as well as for use as a scripting or glue language to
connect existing components together. Python's simple, easy to learn syntax
emphasizes readability and therefore reduces the cost of program maintenance.
Python supports modules and packages, which encourages program modularity
and code reuse. The Python interpreter and the extensive standard library are
available in source or binary form without charge for all major platforms, and
can be freely distributed.

DJANGO:
Django is a high-level python web framework that enables paid development of
secure and maintainable websites. Built by experienced developers, Django
takes care of much of the hassle of web development, So you can focus on
writing your app without needing to reinvent the wheel.

2. ABOUT THE PROJECT

The Student Management System (SMS) is a web-based application developed

using the Django framework. It provides an efficient and comprehensive
solution for managing student-related information in educational institutions.
The system enables administrators, teachers, and students to seamlessly perform
various tasks related to student records, course management, attendance
tracking, and communication. The SMS offers a user-friendly interface that
allows administrators to manage student profiles, including personal details,
academic records, and contact information. It provides features for creating and
updating student records, assigning courses, and generating reports. The system
also allows administrators to manage faculty members, assign roles, and
monitor their activities .Overall, the Student Management System developed
using the Django framework streamlines student-related operations, enhances
communication, and improves administrative efficiency. It simplifies the
management of student records, course assignments, attendance tracking, and
communication, thereby contributing to a more organized and effective
educational environment.

Existing System:
SIS Student Information System: SIS is a Django-based student
information system that enables educational institutions to manage student
records, attendance, grades, schedules, and more. It provides a user-friendly
interface for administrators, teachers, and students to access and update
information.

School Management System (SMS): SMS is a Django-based system that

provides various features for managing students, teachers, courses, grades,
attendance, and more

PROPOSED SYSTEM:
Setup and Configuration:

Install Django and set up a new Django project.

Configure the database settings in the project's settings file.

Create a virtual environment to manage the project's dependencies.

MODELS:

Define the necessary models for the student management system, such as
Student, Course, Enrollment, etc.

Design the fields for each model, including primary keys, foreign keys, and
additional attributes like name, email, grade, etc.

Set up relationships between models using ForeignKey, ManyToManyField, or

OneToOneField as required.

ADMIN INTERFACE:

Register the models in the Django admin interface for easy management.

Customize the admin interface to display relevant fields and provide filters,
search options, and actions.

VIEWS AND TEMPLATES:

Create views to handle various functionalities, such as displaying student

information, course details, enrollment forms, etc.

Define corresponding URL patterns for each view in the project's URL
configuration file.

Design templates using HTML and Django template language to present the
data fetched from views.

FORMS:

Create forms to handle student registration, course enrollment, and other

relevant actions.

Implement form validation to ensure data integrity and proper input.Associate

forms with views to handle form submissions.
2.1 MODULE DESCRIPTION:
LOGIN: Its a multiple login interface where you can login as ADMIN
or as a CLERK.
ADMIN: The admin will have the privileges to access all the functions
in the applications.
CLERK: The Clerk is restricted to some privileges of the application.
MANAGE STUDENT: The Manage Student module will contain two
Sub Modules, that is Manage Existing Student and Add new Student. In
Manage Existing Student Module we can manipulate the Existing
Student Information’s and Update. In Add new Student Module we can
add the new Student to the Database.
MANAGE SUBJECT: In Manage Subject Module we have two Sub
Modules. In Manage Existing Subject Module we can manipulate and
update the Existing Subjects. In Add new subject Module we can add the
New Subjects which contains the Subject name, Subject Code and the
Department in which the subject related to.
MANAGE FEES: This module contains the Fees amount of the each
Department and this Module is Available only to the Admin. The Admin
can Change the Fees Amount for Every Department
REPORT: This Module Contains the All Reports related to the
Students such as Student Details, Marks of Student, Fees Information
etc.. The Admin or the Clerk can print the Reports.
SETTING: In this Module every users can Change their password and
the User Name.
BACK UP: This module deals with backing up of data for future
references or to recover the database tables.
 2.2 INPUT DESIGN

The design of input focus on controlling the amount of dataset as input required,

avoiding delay and keeping the process simple. The input is designed in such a

way to provide security. Input design will consider the following steps:

The dataset should be given as input.

The dataset should be arranged.

Methods for preparing input validations.

PROJECT TITLE: STUDENT MANAGEMENT SYSTEM

DATABASE DESIGN

This phase contains the attributes of the dataset which are maintained in the
database table. The dataset collection can be of two types namely train dataset
and test dataset.

OUTPUT DESIGN

A quality output is one, which meets the requirement of the user and presents
the information clearly. In output design, it is determined how the information is
to be displayed for immediate need.

Designing computer output should proceed in an organized, well thought out

manner the right output must be developed while ensuring that each output
element is designed so that the user will find the system can be used easily and
effectively.
 2.3 REPORTS
SOFTWARE REQUIREMENTS:
1. Processor: Pentium IV
2. Hard Disk: 512GB or more
3. RAM: 8GB or more
4. Operating System: Windows 7, 10, 11,Linux
5. Programming Language: Python, HTML, CSS, Js Bootstrap, Django
IDE/Workbench: Pycharm, visual Studio code

ABOUT SOFTWARE

PYTHON

Python is an interpreted, object-oriented, high-level programming

language with dynamic semantics. Its high-level built in data structures,

combined with dynamic typing and dynamic binding, make it very

attractive for Rapid Application Development, as well as for use as a

scripting or glue language to connect existing components together.

Python's simple, easy to learn syntax emphasizes readability and

therefore reduces the cost of program maintenance. Python supports

modules and packages, which encourages program modularity and code

reuse. The Python interpreter and the extensive standard library are

available in source or binary form without charge for all major platforms,

and can be freely distributed.

PYTHON FEATURES:

Python has few keywords, simple structure, and a clearly defined syntax.

Python code is more clearly defined and visible to the eyes. Python's source

code is fairly easy-to-maintaining. Python's bulk of the library is very portable

and cross-platform compatible on UNIX, Windows, and Macintosh. Python has

support for an interactive mode which allows interactive testing and debugging

of snippets of code.

Portable Python can run on a wide variety of hardware platforms and has the

same interface on all platforms.

EXTENDABLE:

It allows to add low-level modules to the Python interpreter. These modules

enable programmers to add to or customize their tools to be more efficient.

DATABASES:

Python provides interfaces to all major commercial databases.

GUI PROGRAMMING:

Python supports GUI applications that can be created and ported to many

system calls, libraries and windows systems, such as Windows MFC,

Macintosh, and the X Window system of Unix.

SCALABLE:

Python provides a better structure and support for large programs than shell

scripting.

OBJECT-ORIENTED APPROACH:

One of the key aspects of Python is its object-oriented approach. This basically

means that Python recognizes the concept of class and object encapsulation thus

allowing programs to be efficient in the long run.

HIGHLY DYNAMIC:

Python is one of the most dynamic languages available in the industry today.
There is no need to specify the type of the variable during coding, thus saving
time and increasing efficiency.

EXTENSIVE ARRAY OF LIBRARIES:

Python comes inbuilt with many libraries that can be imported at any instance

and be used in a specific program.

OPEN SOURCE AND FREE:

Python is an open-source programming language which means that anyone can

create and contribute to its development. Python is free to download and use in

any operating system, like Windows, Mac or Lin.

PACKAGES IN PYTHON

A package is a hierarchical file directory structure that defines a single Python

application environment

that consists of modules and sub packages and sub-sub packages.

Consider a file Pots.py available in Phone directory. This file has following line
of source code −

def Pots():

print "I'm Pots Phone"

Similar way, we have another two files having different functions with the same
name as above −

• Phone/Isdn.py file having function Isdn()

• Phone/G3.py file having function G3()

Now, create one more file __init__.py in Phone directory −

• Phone/__init__.py

To make all of your functions available when you've imported Phone,to put
explicit import statements in

__init__.py as follows −

from Pots import Pots

from Isdn import Isdn

from G3 import G3

After you add these lines to __init__.py, you have all of these classes available
when you import the
Phone package.

# Now import your Phone Package.

import Phone

Phone.Pots()

Phone.Isdn()

Phone.G3()

RESULT:

I'm Pots Phone

I'm 3G Phone

I'm ISDN Phone

In the above example, we have taken example of a single functions in each file,
but you can keep multiple

functions in your files. You can also define different Python classes in those
files and then you can create

your packages out of those classes .

PYTHON FILES I/O

This chapter covers all the basic I/O functions available in Python.
PRINTING TO THE SCREEN
The simplest way to produce output is using the print statement where you can
pass zero or more
expressions separated by commas. This function converts the expressions you
pass into a string and
writes the result to standard output as follows −
print "Python is really a great language,", "isn't it?"
Result:
Python is really a great language, isn't it?
READING KEYBOARD INPUT
Python provides two built-in functions to read a line of text from standard input,
which by default comes
from the keyboard. These functions are −
• raw_input
• input
Theraw_inputFunction
The raw_input([prompt]) function reads one line from standard input and
returns it as a string (removing
the trailing newline).
str = raw_input("Enter your input: ");
print "Received input is : ", str
This prompts you to enter any string and it would display same string on the
screen. When I typed "Hello
Python!", its output is like this −
Enter your input: Hello Python
Received input is : Hello Python
22 | P a g e
The input Function
The input([prompt]) function is equivalent to raw_input, except that it assumes
the input is a valid Python
expression and returns the evaluated result to you.
str = input("Enter your input: ");
print "Received input is : ", str
This would produce the following result against the entered input −
Enter your input: [x*5 for x in range(2,10,2)]
Recieved input is : [10, 20, 30, 40]
CLASS AND OBJECT
Python has been an object-oriented language since it existed. Because of this,
creating and using classes
and objects are downright easy. This chapter helps you become an expert in
using Python's objectoriented programming support.
If you do not have any previous experience with object-oriented (OO)
programming, you may want to
consult an introductory course on it or at least a tutorial of some sort so that you
have a grasp of the basic
concepts.
However, here is small introduction of Object-Oriented Programming (OOP) to
bring you at speed −
Overview of OOP Terminology
• Class: A user-defined prototype for an object that defines a set of attributes
that characterize
any object of the class. The attributes are data members (class variables and
instance variables) and methods, accessed via dot notation.
• Class variable: A variable that is shared by all instances of a class. Class
variables are defined within a class but outside any of the class's methods. Class
variables are not used as frequently as instance variables are.
• Data member: A class variable or instance variable that holds data associated
with a class and its objects.
• Function overloading: The assignment of more than one behavior to a
particular function.
The operation performed varies by the types of objects or argument
• Instance variable: A variable that is defined inside a method and belongs
only to the current instance of a class.
• Inheritance: The transfer of the characteristics of a class to other classes that
are derived from
it.
: An individual object of a certain class. An object obj that belongs to a class
Circle,
for example, is an instance of the class Circle.
• Instantiation: The creation of an instance of a class.
• Method : A special kind of function that is defined in a class definition.
Object: A unique instance of a data structure that's defined by its class. An
object comprises both data members (class variables and instance variables) and
methods.
• Operator overloading: The assignment of more than one function to a
particular operator.
Creating Classes
The class statement creates a new class definition. The name of the class
immediately follows the
keyword class followed by a colon as follows −
class ClassName:
'Optional class documentation string'
class_suite
• The class has a documentation string, which can be accessed via
ClassName.__doc__.
• The class_suite consists of all the component statements defining class
members, data
attributes and functions.
Class Inheritance
Instead of starting from scratch, you can create a class by deriving it from a pre
existing class by listing the parent class in parentheses after the new class name.
The child class inherits the attributes of its parent class, and you can use those
attributes as if they were defined in the child class. A child class can also
override data members and methods from the parent.
Syntax
Derived classes are declared much like their parent class; however, a list of base
classes to inherit from is given after the class name −
class SubClassName (ParentClass1[, ParentClass2, ...]):
'Optional class documentation string'
class_suite
OVERRIDING METHODS
You can always override your parent class methods. One reason for overriding
parent's methods is because you may want special or different functionality in
your subclass.
Example
class Parent: # define parent class
def myMethod(self):
print 'Calling parent method'
class Child(Parent): # define child class
def myMethod(self):
print 'Calling child method'
c = Child() # instance of child
c.myMethod() # child calls overridden method
When the above code is executed, it produces the following result −
Calling child method
Base Overloading Methods
Following table lists some generic functionality that you can override in your
own classes −
SN Method, Description & Sample Call
1 __init__ ( self [,args...] )
Constructor (with any optional arguments)
Sample Call : obj = className(args)
2 __del__( self )
Destructor, deletes an object
Sample Call : del obj
3 __repr__( self )
Evaluatable string representation
Sample Call : repr(obj)
4 __str__( self )
Printable string representation
Sample Call : str(obj)
5 __cmp__ ( self, x )
Object comparison
Sample Call : cmp(obj, x)
OVERLOADING OPERATORS
Suppose you have created a Vector class to represent two-dimensional vectors,
what happens when you
use the plus operator to add them? Most likely Python will yell at you.
You could, however, define the __add__ method in your class to perform vector
addition and then the
plus operator would behave as per expectation −
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)

def __add__(self,other):
return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2
When the above code is executed, it produces the following result
DATA HIDING

An object's attributes may or may not be visible outside the class definition.
You need to name attributes
with a double underscore prefix, and those attributes then are not be directly
visible to outsiders.
Class JustCounter:
__secretCount = 0

def count(self):
self.__secretCount += 1
print self.__secretCount
counter = JustCounter()
counter.count()
counter.count()
print counter.__secretCount
1
2
Traceback (most recent call last):
File "test.py", line 12, in <module>
print counter.__secretCount
Attribute Error: JustCounter instance has no attribute '__secretCount'
Python protects those members by internally changing the name to include the
class name. You can access such attributes as object._className__attrName. If
you would replace your last line as following, then it works for you .
DJANGO

Overview:
Design your model¶
Although you can use Django without a database, it comes with an object-
relational mapper in which you describe your database layout in Python code.
The data-model syntax offers many rich ways of representing your models – so
far, it’s been solving many years’ worth of database-schema problems. Here’s a
quick example:
mysite/news/models.py¶
from django.db import models

class Reporter(models.Model):
full_name = models.CharField(max_length=70)

def __str__(self):
return self.full_name

class Article(models.Model):
pub_date = models.DateField()
headline = models.CharField(max_length=200)
content = models.TextField()
reporter = models.ForeignKey(Reporter, on_delete=models.CASCADE)

def __str__(self):
return self.headline
Install it¶
Next, run the Django command-line utilities to create the database tables
automatically:

$ python manage.py makemigrations

$ python manage.py migrate

The makemigrations command looks at all your available models and creates
migrations for whichever tables don’t already exist. migrate runs the migrations
and creates tables in your database, as well as optionally providing much richer
schema control.

Enjoy the free API¶

With that, you’ve got a free, and rich, Python API to access your data. The API
is created on the fly, no code generation necessary:

# Import the models we created from our "news" app

>>> from news.models import Article, Reporter

# No reporters are in the system yet.

.

>>> Reporter.objects.all()

<QuerySet []>

# Create a new Reporter.

>>> r = Reporter(full_name="John Smith")

# Save the object into the database. You have to call save() explicitly.

>>> r.save()

# Now it has an ID.

>>> r.id

# Now the new reporter is in the database.

>>> Reporter.objects.all()

<QuerySet [<Reporter: John Smith>]>

# Fields are represented as attributes on the Python object.

>>> r.full_name

'John Smith'

# Django provides a rich database lookup API.

>>> Reporter.objects.get(id=1)

<Reporter: John Smith>

>>> Reporter.objects.get(full_name__startswith="John")

<Reporter: John Smith>

>>> Reporter.objects.get(full_name__contains="mith")

<Reporter: John Smith>

>>> Reporter.objects.get(id=2)

Traceback (most recent call last):

...

DoesNotExist: Reporter matching query does not exist.

# Create an article.

>>> from datetime import date

>>> a = Article(

... pub_date=date.today(), headline="Django is cool", content="Yeah.",

reporter=r

... )

>>> a.save()

# Now the article is in the database.

>>> Article.objects.all()

<QuerySet [<Article: Django is cool>]>

# Article objects get API access to related Reporter objects.

>>> r = a.reporter

>>> r.full_name

'John Smith'
# And vice versa: Reporter objects get API access to Article objects.

>>> r.article_set.all()

<QuerySet [<Article: Django is cool>]>

# The API follows relationships as far as you need, performing efficient

# JOINs for you behind the scenes.

# This finds all articles by a reporter whose name starts with "John".

>>> Article.objects.filter(reporter__full_name__startswith="John")

<QuerySet [<Article: Django is cool>]>

# Change an object by altering its attributes and calling save().

>>> r.full_name = "Billy Goat"

>>> r.save()

# Delete an object with delete().

>>> r.delete()

A dynamic admin interface: it’s not just scaffolding – it’s the whole house¶

Once your models are defined, Django can automatically create a professional,
production ready administrative interface – a website that lets authenticated
users add, change and delete objects. The only step required is to register your
model in the admin site:

mysite/news/models.py¶
from django.db import models

class Article(models.Model):

pub_date = models.DateField()

headline = models.CharField(max_length=200)

content = models.TextField()

reporter = models.ForeignKey(Reporter, on_delete=models.CASCADE)

mysite/news/admin.py¶
from django.contrib import admin

from . import models

admin.site.register(models.Article)
The philosophy here is that your site is edited by a staff, or a client, or maybe
just you – and you don’t want to have to deal with creating backend interfaces
only to manage content.
One typical workflow in creating Django apps is to create models and get the
admin sites up and running as fast as possible, so your staff (or clients) can start
populating data. Then, develop the way data is presented to the public.
Design your URLs¶
A clean, elegant URL scheme is an important detail in a high-quality web
application. Django encourages beautiful URL design and doesn’t put any cruft
in URLs, like .php or .asp.
To design URLs for an app, you create a Python module called a URLconf. A
table of contents for your app, it contains a mapping between URL patterns and
Python callback functions. URLconfs also serve to decouple URLs from Python
code.
Here’s what a URLconf might look like for the Reporter/Article example
above:

mysite/news/urls.py¶

from django.urls import path

from . import views

urlpatterns = [

path("articles/<int:year>/", views.year_archive),

path("articles/<int:year>/<int:month>/", views.month_archive),

path("articles/<int:year>/<int:month>/<int:pk>/", views.article_detail),

The code above maps URL paths to Python callback functions (“views”). The
path strings use parameter tags to “capture” values from the URLs. When a user
requests a page, Django runs through each path, in order, and stops at the first
one that matches the requested URL. (If none of them matches, Django calls a
special-case 404 view.) This is blazingly fast, because the paths are compiled
into regular expressions at load time.

Once one of the URL patterns matches, Django calls the given view, which is a
Python function. Each view gets passed a request object – which contains
request metadata – and the values captured in the pattern.

For example, if a user requested the URL “/articles/2005/05/39323/”, Django

would call the
function news.views.article_detail(request, year=2005, month=5, pk=39323).
Write your views¶

Each view is responsible for doing one of two things: Returning

an HttpResponse object containing the content for the requested page, or
raising an exception such as Http404. The rest is up to you.

Generally, a view retrieves data according to the parameters, loads a template

and renders the template with the retrieved data. Here’s an example view
for year_archive from above:

mysite/news/views.py¶

from django.shortcuts import render

from .models import Article

def year_archive(request, year):

a_list = Article.objects.filter(pub_date__year=year)
context = {"year": year, "article_list": a_list}
return render(request, "news/year_archive.html", context)
This example uses Django’s template system, which has several powerful
features but strives to stay simple enough for non-programmers to use.
Design your templates¶
The code above loads the news/year_archive.html template.
Django has a template search path, which allows you to minimize redundancy
among templates. In your Django settings, you specify a list of directories to
check for templates with DIRS. If a template doesn’t exist in the first directory,
it checks the second, and so on.
Let’s say the news/year_archive.html template was found. Here’s what that
might look like:
mysite/news/templates/news/year_archive.html¶
{% extends "base.html" %}

{% block title %}Articles for {{ year }}{% endblock %}

{% block content %}
<h1>Articles for {{ year }}</h1>

{% for article in article_list %}

<p>{{ article.headline }}</p>
<p>By {{ article.reporter.full_name }}</p>
<p>Published {{ article.pub_date|date:"F j, Y" }}</p>
{% endfor %}
{% endblock %}
Variables are surrounded by double-curly braces. {{ article.headline }} means
“Output the value of the article’s headline attribute.” But dots aren’t used only
for attribute lookup. They also can do dictionary-key lookup, index lookup and
function calls.
Note {{ article.pub_date|date:"F j, Y" }} uses a Unix-style “pipe” (the “|”
character). This is called a template filter, and it’s a way to filter the value of a
variable. In this case, the date filter formats a Python datetime object in the
given format (as found in PHP’s date function).
You can chain together as many filters as you’d like. You can write custom
template filters. You can write custom template tags, which run custom Python
code behind the scenes.
Finally, Django uses the concept of “template inheritance”. That’s what
the {% extends "base.html" %} does. It means “First load the template called
‘base’, which has defined a bunch of blocks, and fill the blocks with the
following blocks.” In short, that lets you dramatically cut down on redundancy
in templates: each template has to define only what’s unique to that template.
Here’s what the “base.html” template, including the use of static files, might
look like:
mysite/templates/base.html¶
{% load static %}
<html>
<head>
<title>{% block title %}{% endblock %}</title>
</head>
<body>
<img src="{% static 'images/sitelogo.png' %}" alt="Logo">
{% block content %}{% endblock %}
</body>
</html>
Simplistically, it defines the look-and-feel of the site (with the site’s logo), and
provides “holes” for child templates to fill. This means that a site redesign can
be done by changing a single file – the base template.
It also lets you create multiple versions of a site, with different base templates,
while reusing child templates. Django’s creators have used this technique to
create strikingly different mobile versions of sites by only creating a new base
template.
Note that you don’t have to use Django’s template system if you prefer another
system. While Django’s template system is particularly well-integrated with
Django’s model layer, nothing forces you to use it. For that matter, you don’t
have to use Django’s database API, either. You can use another database
abstraction layer, you can read XML files, you can read files off disk, or
anything you want. Each piece of Django – models, views, templates – is
decoupled from the next.
This is just the surface¶
This has been only a quick overview of Django’s functionality. Some more
useful features:
 A caching framework that integrates with memcached or other backends.
 A syndication framework that lets you create RSS and Atom feeds by
writing a small Python class.
  More attractive automatically-generated admin features – this overview
barely scratched the surface.

SYSTEM STUDY

System study contains existing and proposed system details. Existing system is

useful to develop proposed system. To elicit the requirements of the system and

to identify the elements, Inputs, Outputs, subsystems and the procedures, the

existing system had to be examined and analyzed in detail.

This increases the total productivity. The use of paper files is avoided and all the

data are efficiently manipulated by the system. It also reduces the space needed

to store the larger paper files and records.

SYSTEM DESIGN

The degree of interest in each concept has varied over the year, each has stood

the test of time. Each provides the software designer with a foundation from

which more sophisticated design methods can be applied. Fundamental design

concepts provide the necessary framework for “getting it right”.

During the design process the software requirements model is transformed into

design models that describe the details of the data structures, system
architecture, interface, and components. Each design product is reviewed for

quality before moving to the next phase of software development.

 CONCLUSION

In conclusion, the student management system developed using Django

provides an efficient and user-friendly platform for managing student-related

tasks and information. The system offers several key features and benefits.

The system ensures secure access to authorized users only. It implements

user authentication and access control mechanisms, allowing administrators,

teachers, and students to log in with unique credentials and access the relevant

features based on their roles.The system allows administrators to create and

manage student profiles, which include essential information such as personal

details, contact information, academic records, attendance, and disciplinary

records. It provides a centralized database for storing and retrieving student

information. Overall, the student management system developed with Django

enhances the efficiency, organization, and communication within an educational

institution. It simplifies the administrative tasks, improves record-keeping, and

provides valuable insights for better student management.

.