UNIT IV

1. Why Tkinter is used for in Python?

Tkinter is the first option for a lot of learners and developers because it is
quick and convenient to use. Tkinter is a Python library that can be used to construct
basic graphical user interface (GUI) applications. In Python, it is the most widely used
module for GUI applications.

2. Write about Web Client?

A web client is a software application that uses hypertext transfer protocol

(HTTP) to format, transmit, and receive requests, web content, services, or resources
from web servers. It's often called a web browser — but a web client is a wider term
that encompasses both web browsers and web applications.

3. HTTP stands for?

HTTP stands for "HyperText Transfer Protocol," and it's the computer
communication protocol used for most communication on the world wide web.

4. What is CGI in Python?

CGI stands for Common Gateway Interface, and it's a standard that allows
web servers to interact with external programs. In Python, CGI was a library that
provided a simple way to write CGI scripts. However, this library was deprecated in
Python 3.11 and removed in Python 3.13.

5. What are Cookies?

Cookies are small files that websites send to your device to store information
about your visit. Cookies can help websites remember your preferences, keep you
signed in, and personalize your experience.

6. What is Web Server?

A web server is a computer that stores and serves web pages to users. When a
user requests a web page, the web server sends the requested file to the user's
browser.

7. What is Tkinter? Explain its usage in detail with examples?

Tkinter Tkinter tutorial provides basic and advanced concepts of Python
Tkinter. Our Tkinter tutorial is designed for beginners and professionals.
Python provides the standard library Tkinter for creating the graphical user interface
for desktop based applications.

Developing desktop based applications with python Tkinter is not a complex task. An
empty Tkinter top-level window can be created by using the following steps.

1. import the Tkinter module.

2. Create the main application window.
 3. Add the widgets like labels, buttons, frames, etc. to the window.
4. Call the main event loop so that the actions can take place on the user's
computer screen.

Example

. # !/usr/bin/python3
. from tkinter import *
. #creating the application main window.
. top = Tk()
. #Entering the event main loop
. [Link]()
Output:

Tkinter widgets

There are various widgets like button, canvas, checkbutton, entry, etc. that are used to
build the python GUI applications.

SN Widget Description
The Button is used to
add various kinds of
1 Button
buttons to the python
application.
The canvas widget is
used to draw the
2 Canvas
canvas on the
window.
The Checkbutton is
used to display the
3 Checkbutton
CheckButton on the
window.
 The entry widget is
used to display the
single-line text field
4 Entry
to the user. It is
commonly used to
accept user values.
It can be defined as a
container to which,
5 Frame
another widget can be
added and organized.
A label is a text used
to display some
6 Label message or
information about the
other widgets.
The ListBox widget
is used to display a
7 ListBox
list of options to the
user.
The Menubutton is
used to display the
8 Menubutton
menu items to the
user.
It is used to add menu
9 Menu
items to the user.
The Message widget
is used to display the
10 Message
message-box to the
user.
The Radiobutton is
different from a
checkbutton. Here,
the user is provided
11 Radiobutton
with various options
and the user can
select only one option
among them.
It is used to provide
12 Scale
the slider to the user.
It provides the
scrollbar to the user
13 Scrollbar so that the user can
scroll the window up
and down.
 It is different from
Entry because it
provides a multi-line
14 Text text field to the user
so that the user can
write the text and edit
the text inside it.
It is used to create a
14 Toplevel separate window
container.
It is an entry widget
15 Spinbox used to select from
options of values.
It is like a container
widget that contains
16 PanedWindow
horizontal or vertical
panes.
A LabelFrame is a
17 LabelFrame container widget that
acts as the container
This module is used
to display the
18 MessageBox message-box in the
desktop based
applications.

Python Tkinter Geometry

The Tkinter geometry specifies the method by using which, the widgets are
represented on display. The python Tkinter provides the following geometry methods.

1. The pack() method

2. The grid() method
3. The place() method

Let's discuss each one of them in detail.

Python Tkinter pack() method

The pack() widget is used to organize widget in the block. The positions widgets
added to the python application using the pack() method can be controlled by using
the various options specified in the method call.

However, the controls are less and widgets are generally added in the less organized
manner.
 The syntax to use the pack() is given below.

syntax

. [Link](options)
A list of possible options that can be passed in pack() is given below.

o expand: If the expand is set to true, the widget expands to fill any space.
o Fill: By default, the fill is set to NONE. However, we can set it to X or Y to
determine whether the widget contains any extra space.
o size: it represents the side of the parent to which the widget is to be placed on
the window.

Example

. # !/usr/bin/python3
. from tkinter import *
. parent = Tk()
. redbutton = Button(parent, text = "Red", fg = "red")
. [Link]( side = LEFT)
. greenbutton = Button(parent, text = "Black", fg = "black")
. [Link]( side = RIGHT )
. bluebutton = Button(parent, text = "Blue", fg = "blue")
. [Link]( side = TOP )
. blackbutton = Button(parent, text = "Green", fg = "red")
. [Link]( side = BOTTOM)
. [Link]()
Output:

Python Tkinter grid() method

The grid() geometry manager organizes the widgets in the tabular form. We can
specify the rows and columns as the options in the method call. We can also specify
the column span (width) or rowspan(height) of a widget.

This is a more organized way to place the widgets to the python application. The
syntax to use the grid() is given below.

Syntax

. [Link](options)
A list of possible options that can be passed inside the grid() method is given below.
 o Column
The column number in which the widget is to be placed. The leftmost column
is represented by 0.
o Columnspan
The width of the widget. It represents the number of columns up to which, the
column is expanded.
o ipadx, ipady
It represents the number of pixels to pad the widget inside the widget's border.
o padx, pady
It represents the number of pixels to pad the widget outside the widget's border.
o row
The row number in which the widget is to be placed. The topmost row is
represented by 0.
o rowspan
The height of the widget, i.e. the number of the row up to which the widget is
expanded.
o Sticky
If the cell is larger than a widget, then sticky is used to specify the position of
the widget inside the cell. It may be the concatenation of the sticky letters
representing the position of the widget. It may be N, E, W, S, NE, NW, NS,
EW, ES.

Example

. # !/usr/bin/python3
. from tkinter import *
. parent = Tk()
. name = Label(parent,text = "Name").grid(row = 0, column = 0)
. e1 = Entry(parent).grid(row = 0, column = 1)
. password = Label(parent,text = "Password").grid(row = 1, column = 0)
. e2 = Entry(parent).grid(row = 1, column = 1)
. submit = Button(parent, text = "Submit").grid(row = 4, column = 0)
. [Link]()
Output:

Python Tkinter place() method

The place() geometry manager organizes the widgets to the specific x and y
coordinates.

Syntax

. [Link](options)
 A list of possible options is given below.

o Anchor: It represents the exact position of the widget within the container.
The default value (direction) is NW (the upper left corner)
o bordermode: The default value of the border type is INSIDE that refers to
ignore the parent's inside the border. The other option is OUTSIDE.
o height, width: It refers to the height and width in pixels.
o relheight, relwidth: It is represented as the float between 0.0 and 1.0
indicating the fraction of the parent's height and width.
o relx, rely: It is represented as the float between 0.0 and 1.0 that is the offset in
the horizontal and vertical direction.
o x, y: It refers to the horizontal and vertical offset in the pixels.

Example

. # !/usr/bin/python3
. from tkinter import *
. top = Tk()
. [Link]("400x250")
. name = Label(top, text = "Name").place(x = 30,y = 50)
. email = Label(top, text = "Email").place(x = 30, y = 90)
. password = Label(top, text = "Password").place(x = 30, y = 130)
. e1 = Entry(top).place(x = 80, y = 50)
. e2 = Entry(top).place(x = 80, y = 90)
. e3 = Entry(top).place(x = 95, y = 130)
. [Link]()
Output:
8. Explain Web Server environment variables for CGI Scripts?

All the CGI programs have access to the following environment variables.
These variables play an important role while writing any CGI program.

[Link]. Variable Name & Description

CONTENT_TYPE
The data type of the content. Used when the client is
1
sending attached content to the server. For example,
file upload.
CONTENT_LENGTH
2 The length of the query information. It is available
only for POST requests.
HTTP_COOKIE
3 Returns the set cookies in the form of key & value
pair.
HTTP_USER_AGENT
The User-Agent request-header field contains
4
information about the user agent originating the
request. It is name of the web browser.
PATH_INFO
5
The path for the CGI script.
QUERY_STRING
6 The URL-encoded information that is sent with GET
method request.
REMOTE_ADDR
7 The IP address of the remote host making the request.
This is useful logging or for authentication.
REMOTE_HOST
The fully qualified name of the host making the
8
request. If this information is not available, then
REMOTE_ADDR can be used to get IR address.
REQUEST_METHOD
9 The method used to make the request. The most
common methods are GET and POST.
SCRIPT_FILENAME
10
The full path to the CGI script.
SCRIPT_NAME
11
The name of the CGI script.
SERVER_NAME
12
The server's hostname or IP Address
13 SERVER_SOFTWARE
[Link]. Variable Name & Description
The name and version of the software the server is
running.

Here is small CGI program to list out all the CGI variables.

#!/usr/bin/python
import os
print "Content-type: text/html\r\n\r\n";
print "<font size=+1>Environment</font><\br>";
for param in [Link]():
print "<b>%20s</b>: %s<\br>" % (param, [Link][param])

CGI stands for common gateway interface. It is an interface that enables the web
server to process a user's HTTPS request by executing a program. It executes a
program that resides on the server to process data to produce the relevant dynamic
content. When a client gives a request or input, this data is passed to the CGI script as
an environment variable, and then the CGI script processes the request and generates
dynamic content for the user's input. Once the web server receives the output
generated by CGI, it sends the response to the client.

CGI programs are called scripts which are written in many popular languages
like Python, PHP, Ruby, etc that interact with a web server to process user input. CGI
scripts are stored in a directory which varies depending on server configuration but
usually, it resides in a special type of directory in a web server called cgi-bin.
Working of CGI in Web Development
The process starts with creating program or writing CGI scripts which can process the
users request and react to it by giving required output. To access CGI script we can
write URL like ([Link]
Configure your web server so that it can recognize the directories in which the CGI
scripts are present. CGI scripts are stored in different directories depending on server
configuration.
In the case when a user or web browser gives request to a URL or a file in the
database within the CGI directory, the HTTP server runs that specific script and
passes the output of the script to web browser.
The CGI script retrieves the source of that entry's page and transforms it into HTML
to give output.
The web server creates a set of environment variables that contain information about
the a particular request. If there exist additional directory names in the URL written
after the script's name like( __/with/additional/path) then this information is stored in
an environment variable called PATH_INFO.
There are two types of method in which the web browser communicate with web
server popularly known as GET and POST.
If in case the request uses the GET method then the data is transferred from web
browser to web sever using GET method. The data transferred using this method is
not secure as it can be easily visible to anyone.
If request can also use the POST method to send data and it is a secure method to
transfer data.
This is how CGI help in the process of web communication with the server and plays
a major role in web development. Although there are many new technologies have
been introduced in past recently which are fast and more secure but CGI has its own
importance in the history of web development.
Role of CGI in Web Development
Python CGI (Common Gateway Interface) plays a significant role in web
development by enabling the execution of Python scripts on a web server to generate
dynamic web content. Here are some key aspects of the role of Python CGI in web
development:
Dynamic Content Generation: CGI allows the creation of dynamic web pages by
executing Python scripts on the server in response to user requests. This is in contrast
to static web pages, which remain the same each time they are loaded.
Interactivity: With CGI, Python scripts can interact with the user, process form data,
and generate customized content based on user input. This interaction is crucial for
creating dynamic and responsive web applications.
Form Handling: CGI scripts are commonly used to handle HTML forms submitted by
users. The data from these forms is sent to the server, processed by the Python script,
and the script generates a response based on the form data.
Server-Side Scripting: Python CGI allows for server-side scripting, where the script is
executed on the server before the results are sent to the user's web browser. This is
different from client-side scripting, where scripts run on the user's browser.
Integration with Web Servers: CGI is supported by most web servers, making it a
versatile choice for running Python scripts. Popular web servers like Apache, Nginx,
and others can be configured to execute CGI scripts in response to specific URL
requests.
Data Processing: CGI scripts can be used for processing and managing data on the
server side. This includes tasks such as database access, file manipulation, and other
server-side operations.
Scalability: While CGI is a simple and widely supported way to run scripts on a web
server, it may not be as efficient or scalable as more modern approaches like FastCGI,
WSGI (Web Server Gateway Interface), or application frameworks
(e.g., Flask, Django). These alternatives are often preferred for larger and more
complex web applications.
Environment Variables Used in CGI
 CONTENT_LENGTH : It specifies the length of URL encoded data in bytes.
REMOTE_HOST : resolved host name of the client.
CONTENT_TYPE : It specifies the type of data as a MIME header.
QUERY_STRING : Gives information at the end of the URL after ?
REMOTE_ADDR : IP address of the client making the request.
REQUEST_METHOD: It gives the HTTP request method(GET or POST ).
SCRIPT_NAME : Name of the CGI script which is being run.
Advantages of CGI
It is easy to develop a CGI program and deploy to process users request.
It helps in creating a connection between web server and web browser.
They can be used to generate dynamic web content.
CGI can be programed by using almost any language.
It has access to multiple environment variables support.
Disadvantages of CGI
It is slow while giving multiple output when user requests are very large. It eventually
reduces the speed of the process.
CGI scripts are not secure and vulnerable to attacks. Which may leads to disclosure of
sensitive information.
Do not have its own pre defined frameworks.
Level up your coding with DSA Python in 90 da

9. Explain about Web Server and Web Clients?

In Python, a "web server" is a software application that listens for HTTP
requests from "web clients" (like a web browser) and sends back responses, typically
in the form of HTML pages, images, or other web content, based on the request
received; essentially acting as a middle ground to deliver web content when a client
requests it through a URL, all communication happening through the HTTP protocol.

Key points about web servers and clients in Python:

Client-Server Model:

This interaction follows the client-server model, where the web browser (client)
initiates a request to the web server, which then processes the request and sends back
a response.
HTTP Protocol:

The communication between the client and server happens using the Hypertext
Transfer Protocol (HTTP), which defines the format of requests and responses.

Python Modules:

To build a web server in Python, you primarily use the built-in [Link] module
which provides classes like HTTPServer and BaseHTTPRequestHandler to handle
incoming requests and generate responses.
How it works:
1. Client Request:
 When you type a URL in your browser, the browser sends an HTTP request to the
web server specified by the URL.

2. Server Processing:
The web server receives the request, parses it to identify the requested resource (like
a specific webpage), retrieves the data from its storage, and generates an HTTP
response.
3. Server Response:
The server sends back the response to the client, which includes the requested
content (HTML, images, etc.) along with status codes indicating whether the request
was successful.
Example of a simple Python web server using the [Link] module:
Code
from [Link] import HTTPServer, SimpleHTTPRequestHandler

PORT = 8000

with HTTPServer(("", PORT), SimpleHTTPRequestHandler) as httpd:

print("Serving at port", PORT)
httpd.serve_forever()
Important aspects of web servers in Python:

Web Frameworks:

To build more complex web applications, developers often use web frameworks like
Flask, Django, or Pyramid which provide additional features like routing, templating,
and database integration on top of the basic HTTP server functionality.

Custom Handlers:

You can create custom BaseHTTPRequestHandler subclasses to handle specific

request types or perform additional processing on incoming requests.

10. Write about CGI and CGI applications?

CGI stands for Common Gateway Interface in Python which is a set of
standards that explains how information or data is exchanged between the web server
and a routine script.
The Common Gateway Interface is a standard for external gateway programs to
interface with the server, such as HTTP Servers. In simple words, it is the collection
of methods used to set up a dynamic interaction between the server, and the client
application.

Applications of Common Gateway Interface

 Forms. Forms are one of the most significant users of CGI. ...
 Gateway. Web gateways are alike programs or scripts. ...
 Virtual Documents. ...
 Lycos World Wide Web Search. ...
 Coloring Book. ...
 Japanese to English Dictionary. ...
 Guestbook with World Map.

cGI stands for Common Gateway Interface in Python which is a set of standards that
explains how information or data is exchanged between the web server and a routine
script. This interface is used by web servers to route information requests supplied by
a browser or we can say that CGI is customary for external gateway programs to
interface with information servers such as HTTP servers.
A CGI script is invoked by an HTTP server, usually to course user input which is
submitted through an HTML <FORM> or an <ISINDEX> element.
Concept of CGI
Whenever we click on a hyperlink to browse a particular web page or URL, our
browser interacts with the HTTP web server and asks for the same URL (or filename).
Web Server then parses the URL and looks for the same filename. If that file is found,
then that file is sent back to the browser, otherwise, an error message is sent
indicating that we are demanding the wrong file. Web browser takes the response
from a web server and displays it, then whether it is the received file from the
webserver or an error message. But, conversely, it is possible to set up the HTTP
server so that whenever a specific file is requested, then that file is not sent back, but
instead, it is executed as a program, and whatever that program output is, that is sent
back to our browser for display. This same function is called the Common Gateway
Interface (or CGI) and the programs which are executed are called CGI scripts. In
python, these CGI programs are Python Script.
Architecture of CGI:

Example:
Let us take a sample URL which passes two values to first_cgi.py program using GET
method:
/cgi-bin/first_cgi.py?your_name=Piyush&company_name=GeeksforGeeks
Below is the first_cgi.py script to handle the input given by the above sample URL.
Here we will use cgi module which will makes it very easy to access the passed
information

#!/usr/bin/python

# Import CGI and CGIT module

import cgi, cgitb

# to create instance of FieldStorage

# class which we can use to work
# with the submitted form data
form = [Link]()
your_name =
[Link]('your_name')

# to get the data from fields

comapny_name =
[Link]('company_name')

print ("Content-type:text/html\n")
print ("<html>")
print ("<head>")
print ("<title>First CGI Program</title>")
print ("</head>")
print ("<body>")
print ("<h2>Hello, %s is working
in %s</h2>"
% (your_name, company_name))

print ("</body>")
print ("</html>")
Output:
Hello, Piyush is working in GeeksforGeeks

11. Explain the concept of MultiThreading Environment in Python?

Multithreading in Python involves running multiple threads concurrently
within a single process to achieve parallelism and utilize multiple CPU cores .
Multithreading in Python involves creating and managing multiple threads
within a program. Threads execute concurrently, enabling parallel execution of tasks.
This can improve performance, facilitate concurrent operations, and enhance
responsiveness, especially for I/O-bound tasks or operations involving waiting.
In computing, a process is an instance of a computer program that is being executed.
Any process has 3 basic components:
An executable program.
The associated data needed by the program (variables, workspace, buffers, etc.)
The execution context of the program (State of the process)
An Intro to Python Threading
A thread is an entity within a process that can be scheduled for execution. Also, it is
the smallest unit of processing that can be performed in an OS (Operating System). In
simple words, a thread is a sequence of such instructions within a program that can be
executed independently of other code. For simplicity, you can assume that a thread is
simply a subset of a process! A thread contains all this information in a Thread
Control Block (TCB) :
Thread Identifier: Unique id (TID) is assigned to every new thread
Stack pointer: Points to the thread’s stack in the process. The stack contains the local
variables under the thread’s scope.
Program counter: a register that stores the address of the instruction currently being
executed by a thread.
Thread state: can be running, ready, waiting, starting, or done.
Thread’s register set: registers assigned to thread for computations.
Parent process Pointer: A pointer to the Process control block (PCB) of the process
that the thread lives on.
Consider the diagram below to understand the relationship between the process and its
thread:

Relationship between a Process and its Thread

Multiple threads can exist within one process where:

Each thread contains its own register set and local variables (stored in the stack) .
All threads of a process share global variables (stored in heap) and the program code .
Consider the diagram below to understand how multiple threads exist in memory:

Existence of multiple threads in memory

An Intro to Threading in Python

Multithreading is defined as the ability of a processor to execute multiple threads
concurrently. In a simple, single-core CPU, it is achieved using frequent switching
between threads. This is termed context switching . In context switching, the state of a
thread is saved and the state of another thread is loaded whenever any interrupt (due
to I/O or manually set) takes place. Context switching takes place so frequently that
all the threads appear to be running parallelly (this is termed multitasking ).
Consider the diagram below in which a process contains two active threads:
Multithreading

Multithreading in Python
In Python , the threading module provides a very simple and intuitive API for
spawning multiple threads in a program. Let us try to understand multithreading code
step-by-step.
Step 1: Import Module
First, import the threading module.
import threading
Step 2: Create a Thread
To create a new thread, we create an object of the Thread class. It takes the ‘target’
and ‘args’ as the parameters. The target is the function to be executed by the thread
whereas the args is the arguments to be passed to the target function.
t1 = [Link](target, args)
t2 = [Link](target, args)
Step 3: Start a Thread
To start a thread, we use the start() method of the Thread class.
[Link]()
[Link]()
Step 4: End the thread Execution
Once the threads start, the current program (you can think of it like a main thread)
also keeps on executing. In order to stop the execution of the current program until a
thread is complete, we use the join() method.
[Link]()
[Link]()
As a result, the current program will first wait for the completion of t1 and then t2 .
Once, they are finished, the remaining statements of the current program are executed.
Example:
Let us consider a simple example using a threading module.
This code demonstrates how to use Python’s threading module to calculate the square
and cube of a number concurrently. Two threads, t1 and t2 , are created to perform
these calculations. They are started, and their results are printed in parallel before the
program prints “Done!” when both threads have finished. Threading is used to
achieve parallelism and improve program performance when dealing with
computationally intensive tasks.
import threading

def print_cube(num):
 print("Cube: {}" .format(num * num * num))

def print_square(num):
print("Square: {}" .format(num * num))

if __name__ =="__main__":
t1 = [Link](target=print_square, args=(10,))
t2 = [Link](target=print_cube, args=(10,))

[Link]()
[Link]()

[Link]()
[Link]()

print("Done!")

Output
Square: 100
Cube: 1000
Done!
Consider the diagram below for a better understanding of how the above program
works:

Multithreading

Example:
In this example, we use [Link]() function to get the ID of the current process. We
use threading.main_thread() function to get the main thread object. In normal
conditions, the main thread is the thread from which the Python interpreter was
started. name attribute of the thread object is used to get the name of the thread. Then
we use the threading.current_thread() function to get the current thread object.
Consider the Python program given below in which we print the thread name and
corresponding process for each task.
This code demonstrates how to use Python’s threading module to run two tasks
concurrently. The main program initiates two threads, t1 and t2 , each responsible for
executing a specific task. The threads run in parallel, and the code provides
information about the process ID and thread names. The os module is used to access
the process ID, and the ‘ threading' module is used to manage threads and their
execution.
import threadingimport os
def task1():
print("Task 1 assigned to thread: {}".format(threading.current_thread().name))
print("ID of process running task 1: {}".format([Link]()))
def task2():
print("Task 2 assigned to thread: {}".format(threading.current_thread().name))
print("ID of process running task 2: {}".format([Link]()))
if __name__ == "__main__":

print("ID of process running main program: {}".format([Link]()))

print("Main thread name: {}".format(threading.current_thread().name))

t1 = [Link](target=task1, name='t1')
t2 = [Link](target=task2, name='t2')

[Link]()
[Link]()

[Link]()
[Link]()

Output
ID of process running main program: 19
Main thread name: MainThread
Task 1 assigned to thread: t1
ID of process running task 1: 19
Task 2 assigned to thread: t2
ID of process running task 2: 19
The diagram given below clears the above concept:
Multithreading

So, this was a brief introduction to multithreading in Python. The next article in this
series covers synchronization between multiple threads . Multithreading in Python |
Set 2 (Synchronization)
Python ThreadPool
A thread pool is a collection of threads that are created in advance and can be reused
to execute multiple tasks. The [Link] module in Python provides a
ThreadPoolExecutor class that makes it easy to create and manage a thread pool.
In this example, we define a function worker that will run in a thread. We create a
ThreadPoolExecutor with a maximum of 2 worker threads. We then submit two tasks
to the pool using the submit method. The pool manages the execution of the tasks in
its worker threads. We use the shutdown method to wait for all tasks to complete
before the main thread continues.
Multithreading can help you make your programs more efficient and responsive.
However, it’s important to be careful when working with threads to avoid issues such
as race conditions and deadlocks.
This code uses a thread pool created with [Link] to
run two worker tasks concurrently. The main thread waits for the worker threads to
finish using [Link](wait=True) . This allows for efficient parallel processing
of tasks in a multi-threaded environment.
import [Link]
def worker():
print("Worker thread running")
pool = [Link](max_workers=2)
[Link](worker)[Link](worker)
[Link](wait=True)
print("Main thread continuing to run")
 Output
Worker thread running
Worker thread running
Main thread continuing to run

12. Explain UI Framework in Python using Django?

In Python, a UI framework like Django essentially provides a structured set of
tools and components to build the user interface (UI) of a web application, allowing
developers to focus on the application logic rather than writing low-level HTML, CSS,
and JavaScript code from scratch; with Django, this means creating dynamic web
pages with features like forms, user authentication, database interactions, and more,
all within a well-defined architecture based on the Model-View-Controller (MVC)
pattern.

Key points about Django as a UI framework:


High-level:

Django is considered a high-level framework, meaning it abstracts away many
complexities of web development, providing ready-to-use components for common
tasks like routing, templating, database management, and security.


MVC architecture:

Django follows the MVC pattern, where:

 Models: Represent data structures stored in the database.
 Views: Process user requests, retrieve data from models, and generate
responses (often in the form of rendered templates).
 Templates: Define the visual presentation of data using HTML-like
syntax with Django template tags.

Built-in features:

Django comes with a rich set of features "out of the box" including:

 Object Relational Mapper (ORM): Simplifies database interactions
by allowing you to work with database tables as Python objects.
 Admin interface: Provides a web-based interface to manage data in
the database easily.
 User authentication system: Handles user logins, registration, and
permissions with minimal code.
 URL routing system: Maps URLs to specific views in your
application.
 Example of a simple Django view and template:
Code
# [Link]
from [Link] import render

def home_view(request):
context = {
"title": "Welcome to our website!"
}
return render(request, '[Link]', context)

# templates/[Link]
<!DOCTYPE html>
<html>
<head>
<title>{{ title }}</title>
</head>
<body>
<h1>{{ title }}</h1>
</body>
</html>

Key points to remember:


Not a front-end framework:

While Django handles the backend logic and templating, you will still need to use a
client-side JavaScript framework (like React, Vue, or Angular) for complex
interactive UI elements.


Scalability:

Django is designed to handle large and complex web applications due to its robust
architecture an


Python Django is a web framework that allows to quickly create efficient web pages.
Django is also called batteries included framework because it provides built-in
features such as Django Admin Interface, default database – SQLite3, etc. When
you’re building a website, you always need a similar set of components: a way to
handle user authentication (signing up, signing in, signing out), a management panel
for your website, forms, a way to upload files, etc. Django gives you ready-made
components to use.
Why Django Framework?
Excellent documentation and high scalability.
Used by Top MNCs and Companies, such as Instagram, Disqus, Spotify, Youtube,
Bitbucket, Dropbox, etc. and the list is never-ending.
Easiest Framework to learn, rapid development, and Batteries fully included. Django
is a rapid web development framework that can be used to develop fully fleshed web
applications in a short period of time.
The last but not least reason to learn Django is Python, Python has a huge library and
features such as Web Scraping, Machine Learning, Image Processing, Scientific
Computing, etc. One can integrate all this with web applications and do lots and lots
of advanced stuff.
Django Architecture
Django is based on MVT (Model-View-Template) architecture which has the
following three parts –
Model: The model is going to act as the interface of your data. It is responsible for
maintaining data. It is the logical data structure behind the entire application and is
represented by a database (generally relational databases such as MySql, Postgres).
View: The View is the user interface that you see in your browser when you render a
website. It is represented by HTML/CSS/Javascript and Jinja files.
Template: A template consists of static parts of the desired HTML output as well as
some special syntax describing how dynamic content will be inserted. To check more,
visit – Django Templates