GGS COLLEGE OF MODERN TECHNOLOGY

KHARAR

ASSIGNMENT – II
PROGRAMING IN PYTHON
BTCS510-18

Submitted to :- Munish Sir

Submitted by:- Eshan Padhiar
Roll No: 2103769
Course: B. Tech
Semester: 5th
Department: CSE
Ques 1. What is regular expression
Answer : A regular expression (regex or regexp) in Python is a powerful and versatile tool
for pattern matching and text manipulation. It is a sequence of characters that defines a
search pattern. Regular expressions are used to search for and manipulate text strings based
on specific patterns and rules.
In Python, regular expressions are implemented through the re module, which provides
functions and classes to work with regular expressions. Here are some of the common uses
of regular expressions in Python:
 Pattern Matching: Regular expressions can be used to search for specific patterns or
substrings within a text. This is useful for tasks such as finding email addresses, phone
numbers, URLs, or other structured data within a larger text.

 String Validation: Regular expressions can be employed to validate whether a given

string adheres to a particular pattern or format. For instance, you can validate whether
a string is a valid email address, phone number, or ZIP code.

 Text Extraction: Regular expressions can be used to extract specific portions of text
from a larger body of text. For example, you can extract all the words from a
document or all the URLs from a web page.

 Text Replacement: Regular expressions allow you to search for a pattern and replace
it with another string. This is useful for text cleaning and manipulation tasks.

Ques 2. Write short notes on

i) Res
ii) CGI

Answer : In Python, "res" is often used as a common abbreviation for "result." It is a

variable name that developers use to store the result of an operation or a computation. While
"res" itself is not a built-in keyword or reserved word in Python, it's a widely used naming
convention for result variables in code.
Here's a simple example of using "res" to store the result of a mathematical operation:
In this example, the variable "res" stores the result of the addition operation, which is then
printed to the console. Using meaningful variable names, like "res" for "result," can make
code more readable and self-explanatory.
It's important to note that "res" is not a special or reserved term in Python; it's just a common
naming convention used by developers to make their code more understandable. The choice
of variable names is largely a matter of coding style and should be chosen to enhance the
clarity and maintainability of the code.

CGI
CGI, or Common Gateway Interface, is a standard protocol that allows web servers to
execute external programs, typically written in scripting languages like Python, to generate
dynamic web content. In Python, you can use CGI to create web applications that generate
web pages, interact with databases, or perform various tasks in response to web requests.
Here's a brief overview of CGI in Python:
 How CGI Works:
o When a web server receives an HTTP request for a resource (e.g., a web page or
a script), it can recognize that the resource is a CGI script based on its file
extension (e.g., .py, .cgi).
o The server launches the specified script as a separate process.
o The script processes the request, generates dynamic content (HTML, JSON,
etc.), and sends the content back to the web server.
o The server then delivers the generated content to the client's web browser for
display.
 Using Python for CGI:
o To create a CGI script in Python, you typically write Python code that reads and
processes data from the incoming HTTP request (e.g., form data or query
parameters) and generates an appropriate HTTP response.
o You can use the cgi module in Python to parse and access CGI-related
environment variables and input data. The cgitb module is also useful for
handling errors and exceptions in CGI scripts.
 o Make sure the Python script is executable and configured correctly in the web
server's CGI directory.
 Security Considerations:
o CGI scripts must be carefully written to prevent security vulnerabilities, such as
code injection or unauthorized access.
o You should validate and sanitize user input and avoid executing external
commands or relying on untrusted data.
 Deployment:
o To deploy a Python CGI script, you'll need a web server (e.g., Apache)
configured to support CGI.
o The script should be placed in a designated CGI directory with executable
permissions.
o Proper server configuration is necessary to map URLs to the corresponding CGI
script files.
 Alternatives to CGI:
o While CGI is still used in some cases, it's not the most efficient or modern
approach for building web applications. Alternatives like WSGI (Web Server
Gateway Interface) and frameworks such as Flask and Django provide more
robust and efficient solutions for Python web development.
 In summary, CGI in Python allows you to create dynamic web applications by
executing Python scripts in response to web requests. However, due to its performance
limitations and security concerns, modern web development in Python often relies on
more advanced approaches, like web frameworks and application servers.

Ques 3. What is Multithreaded programming

Answer : Multithreaded programming in Python refers to the practice of creating and
managing multiple threads within a Python program to achieve concurrent execution of
tasks. Python provides a built-in module called threading that facilitates multithreading.
Threads are lightweight sub-processes that share the same memory space within a Python
process, making it possible to run multiple threads concurrently and achieve parallelism.
Here's an overview of multithreaded programming in Python:
 The threading Module: Python's threading module allows you to work with threads.
You can create threads, start and stop them, and coordinate their execution. This
module is part of the Python standard library and is widely used for multithreaded
programming.
 Creating Threads: To create a thread, you typically define a function that represents
the task you want the thread to perform. You then create a thread object, passing the
function as the target. For example:
Starting Threads: Once you have created thread objects, you can start them to initiate their
execution. Each thread runs its designated function concurrently. To start a thread, you call
the start method on the thread object:

 Thread Coordination: Multithreaded programs often require coordination between

threads. Python provides synchronization mechanisms like locks, semaphores, and
conditions to ensure that threads can safely access shared resources and avoid race
conditions.
 Thread Safety: When working with threads that share data, it's important to ensure
thread safety. Without proper synchronization, multiple threads accessing and
modifying shared data can lead to unpredictable and erroneous behavior. Thread
safety is achieved through synchronization mechanisms and careful design.
 Global Interpreter Lock (GIL): Python has a Global Interpreter Lock (GIL) that
prevents multiple native threads from executing Python bytecodes simultaneously in a
single Python process. This can limit the extent of parallelism that can be achieved in
CPU-bound tasks with pure Python threads. However, the GIL does not prevent the
benefits of multithreading in I/O-bound tasks, where threads can still provide
concurrency.
 Multiprocessing Module: To achieve true parallelism on multi-core processors, you
can also use Python's multiprocessing module, which spawns separate processes,
each with its own Python interpreter and memory space. This can overcome the
limitations of the GIL for CPU-bound tasks.
Multithreaded programming in Python is useful for various tasks, including concurrent I/O
operations, running background tasks, and building responsive applications. It allows
developers to take advantage of multi-core processors and efficiently utilize available
resources. However, multithreaded programming also comes with challenges related to
synchronization and debugging, which need to be addressed for robust and reliable
concurrent code.

Ques 4. What is Object Relational Managers?

Answer : In Python, an Object-Relational Mapper (ORM) is a programming library or
framework that provides an abstraction layer for interacting with relational databases. The
primary goal of an ORM is to bridge the gap between the object-oriented programming
paradigm and the relational database model, making it easier for developers to work with
databases using Python objects and code.
Here are key aspects of Object-Relational Mappers in Python:
 Object-Relational Mapping: ORM allows developers to work with database records
as if they were objects in their programming language (e.g., Python). This means you
can create, update, query, and delete database records using high-level, object-oriented
code rather than writing raw SQL queries.
 Mapping Tables to Classes: In an ORM, database tables are typically represented as
classes, and rows in the tables become instances of these classes. Each class attribute
typically corresponds to a column in the database table.
 Abstraction of SQL: ORMs abstract the SQL (Structured Query Language) queries
required for database operations. Developers can perform database operations using
Python methods and properties provided by the ORM library, and the ORM translates
these high-level operations into SQL queries.
 Cross-Database Compatibility: ORMs often provide a level of database abstraction,
enabling applications to work with multiple relational database systems (e.g.,
PostgreSQL, MySQL, SQLite) without changing the application code. This is useful
for portability and flexibility.
 Query Building: ORMs offer query-building capabilities to construct complex
database queries using Python methods and expressions. This simplifies the process of
constructing SQL queries manually.
 Relationship Handling: ORMs provide mechanisms to define and manage
relationships between database tables. For example, they support one-to-one, one-to-
many, and many-to-many relationships.
 Automatic Table Creation: Many ORMs can automatically generate database tables
and schema based on the defined Python classes, making it easier to create and
maintain the database schema.
 Data Validation and Type Casting: ORMs often include validation and type casting
features to ensure that data stored in the database is consistent and follows data
integrity rules.
Common Python ORM libraries and frameworks include:
 Django ORM: Part of the Django web framework, it offers a robust ORM for
building web applications.
 SQLAlchemy: A powerful and highly customizable ORM library that can be used
with various databases.
 Peewee: A lightweight and easy-to-use ORM that's well-suited for small to medium-
sized projects.
 SQLObject: A simple and straightforward ORM that provides an easy way to interact
with databases.
Using an ORM can simplify database-related tasks in Python development, reduce the
amount of SQL code you need to write, and help ensure data consistency and integrity.
However, understanding how to use the specific ORM you choose effectively is essential for
making the most of its features and capabilities.