Assignment: - Python Programming Language Paper Code: - MCA-

43(iv)

Semester: - 4th Total Marks: - 30

Important Instructions

 Attempt all questions from each assignment given below.

 Each assignment carries 15 marks.
 All questions are to be attempted in legible handwriting on plane
white A-4 size paper and upload the scanned copy of the
assignments on student’s portal and 2 Copies are to be submitted to
the department.

Assignment – 01

Q1. Discuss the key features of Python that distinguish it from other
programming languages. Why is Python considered both beginner-friendly
and powerful for professionals?

Ans.

Python is a high-level, interpreted programming language known for its

simplicity, versatility, and readability. It stands out among other
programming languages due to several distinctive features that make it
both beginner-friendly and powerful for professionals.

🔑 Key Features that Distinguish Python:

1. Simplicity and Readability:

o Python syntax is clean and close to the English language,

which makes it easy to read and write.

o Unlike languages like Java or C++, Python does not require

the use of semicolons or braces to define blocks of code.
Instead, it uses indentation, making code more readable and
organized.

2. Interpreted Language:

o Python is interpreted line-by-line, which simplifies debugging

and testing.

o No need to compile the code before execution—errors are

easier to identify and fix on the fly.

3. Dynamically Typed:
 o Python does not require explicit declaration of variable types.
The interpreter automatically determines the data type at
runtime.

o This leads to quicker development and less verbose code.

4. Extensive Standard Library:

o Python comes with a vast collection of built-in modules and

functions, known as the standard library, which supports
everything from regular expressions to file I/O to networking.

o This reduces the need for writing code from scratch for
common tasks.

5. High-Level Language:

o Python abstracts low-level details such as memory

management, pointers, etc., allowing developers to focus
more on solving problems rather than managing the
hardware.

6. Portable and Cross-Platform:

o Python code can run on different operating systems like

Windows, Linux, and macOS without modification, as long as
the Python interpreter is available.

7. Community Support and Open Source:

o Python is open-source and has a massive global community

that continuously contributes to its growth.

o This results in vast documentation, third-party libraries, and

helpful forums.

8. Extensibility and Integration:

o Python can be easily integrated with other programming

languages like C, C++, or Java.

o It can also be embedded into applications as a scripting

language.

🌱 Why Python is Beginner-Friendly:

 Minimal Syntax Rules: Beginners can focus on learning concepts

rather than syntax.
  Interactive Mode: Python’s interactive shell allows for real-time
testing and learning.

 Rich Learning Resources: A large ecosystem of tutorials,

documentation, and beginner projects.

 Immediate Feedback: Errors are shown instantly, helping learners

understand what went wrong.

🚀 Why Python is Powerful for Professionals:

 Wide Application Domains: Used in web development, data

science, artificial intelligence, machine learning, automation,
cybersecurity, game development, and more.

 Scalability: Python is used by major companies like Google, Netflix,

and Dropbox to build scalable, maintainable systems.

 Frameworks and Tools: Professionals leverage powerful

frameworks like Django (web), TensorFlow (ML), Pandas (data), and
Flask (API development).

 Rapid Prototyping: Python allows developers to move from idea to

execution quickly, making it perfect for startups and R&D.

✅ Conclusion:

Python’s clean syntax and beginner-friendly design make it an ideal first

language, while its depth, library support, and community make it a go-to
tool for professionals solving complex, real-world problems. Its ability to
scale from scripting small tasks to powering enterprise applications is
what truly sets it apart.
Q2. Explain the different data types available in Python. Describe how
Python handles type conversion and the significance of dynamic typing.

Ans.

Python is a dynamically typed, high-level programming language

that supports various data types to handle and manipulate different kinds
of data. Understanding Python’s data types and its approach to type
conversion and dynamic typing is essential for efficient coding and
program logic.

1. Built-in Data Types in Python

Python provides several built-in data types, categorized as follows:

A. Numeric Types

 int: Represents whole numbers (e.g., 10, -3, 1000)

 float: Represents real numbers or decimal values (e.g., 3.14, -0.5)

 complex: Represents complex numbers (e.g., 2+3j)

B. Sequence Types

 str: A sequence of Unicode characters (e.g., "hello", 'A')

 list: An ordered, mutable collection (e.g., [1, 2, 3])

 tuple: An ordered, immutable collection (e.g., (1, 2, 3))

C. Set Types

 set: An unordered collection of unique items (e.g., {1, 2, 3})

 frozenset: Like a set but immutable

D. Mapping Type

 dict: A collection of key-value pairs (e.g., {'name': 'Lalit', 'age': 21})

E. Boolean Type

 bool: Represents either True or False

F. Binary Types

 bytes: Immutable sequence of bytes

  bytearray: Mutable sequence of bytes

 memoryview: Used to access the internal data of an object

G. None Type

 None: Represents the absence of a value (used when a function

doesn't return anything)

2. Type Conversion in Python

Python supports two types of type conversion:

A. Implicit Type Conversion

 Done automatically by Python when no data loss is expected.

 Example:

a = 10 # int

b = 3.5 # float

c = a + b # c becomes 13.5 (float)

B. Explicit Type Conversion (Type Casting)

 Programmer manually converts one data type to another using built-

in functions like:

o int(), float(), str(), list(), tuple(), set(), etc.

 Example:

a = "100"

b = int(a) # converts string to integer

3. Dynamic Typing in Python

Python is a dynamically typed language, meaning:

 You don’t need to declare the type of a variable when creating it.

 A variable’s type is determined at runtime based on the value

assigned to it.

 You can reassign a variable to a different type at any point in the

program.

Example:

x = 10 # int
x = "hello" # now it's a string

x = [1, 2, 3] # now a list

Significance of Dynamic Typing:

 Flexibility: Allows variables to hold different types of data.

 Ease of Use: Reduces boilerplate code and speeds up

development.

 Drawback: Can lead to runtime errors if type usage is not

carefully handled (since type checking happens at runtime).

Conclusion

Python's data types provide the foundation for managing data effectively.
Its automatic type conversion, support for explicit casting, and
dynamic typing model make it powerful yet flexible. However, this
flexibility comes at the cost of potential type-related errors, which
programmers must guard against. Mastering these concepts is key to
writing efficient and error-free Python code.
Q3. What are functions in Python? Discuss the importance of functions in
code reusability and modular programming. Also, explain the concept of
scope and lifetime of variables in Python functions.

Ans.

Functions in Python

Definition:

A function in Python is a self-contained block of code designed to

perform a specific task. It is defined once and can be executed whenever
required, simply by calling it by name. Python supports both built-in
functions (like len(), max(), etc.) and user-defined functions created
using the def keyword.

Importance of Functions in Code Reusability and Modular

Programming

1. Code Reusability:

Functions enable programmers to write code once and reuse it multiple

times without rewriting the same logic. This drastically reduces
redundancy in a program, minimizes errors, and enhances maintainability.

 Instead of duplicating code blocks, a function can be invoked

repeatedly wherever needed.

 Enhances clarity by abstracting complex operations into simple

function calls.

2. Modular Programming:

Functions are a cornerstone of modular programming, which

emphasizes breaking down a large problem into smaller, manageable
parts called modules.

 Each function handles a specific task or logic, making the overall

program easier to design, test, debug, and extend.

 Promotes separation of concerns, where each function can be

developed and tested independently.

3. Enhances Readability and Maintainability:

  Functions improve the logical structure of code, making it more
readable.

 Changes in logic need to be made in one place only—inside the

function—without affecting other parts of the program.

4. Promotes Collaboration:

 In team-based projects, functions enable multiple developers to

work on different parts of a program simultaneously.

 Functions serve as well-defined interfaces between different parts of

code.

Scope and Lifetime of Variables in Python Functions

1. Scope of Variables:

The scope of a variable refers to the region or part of the program where
the variable is accessible.

Types of Scope in Python:

 Local Scope: Variables defined inside a function are local to that

function and cannot be accessed from outside.

 Global Scope: Variables defined outside all functions are global and
can be accessed from anywhere in the program (unless shadowed
by local variables).

 Enclosed Scope: For nested functions, the inner function has

access to the variables of the outer function (nonlocal scope).

 Built-in Scope: Refers to names preassigned in Python (like print,

int, etc.)

Python follows the LEGB Rule (Local → Enclosed → Global → Built-in) to

resolve variable names.

2. Lifetime of Variables:

The lifetime of a variable refers to the duration for which the variable
exists in memory.

 Local variables: Created when the function is called, and

destroyed once the function execution is complete.
  Global variables: Exist throughout the execution of the program,
until the program terminates.

The concept of variable lifetime ensures efficient use of memory, as

temporary values used inside functions do not persist beyond their use.

Conclusion:

Functions are essential to structured and efficient programming in

Python. They enable code reuse, simplify complex problems through
modularization, and support better organization of logic. Understanding
the scope and lifetime of variables ensures that data is used properly
within the boundaries it is defined, preventing errors and unintended
behavior. Thus, functions are not just tools for convenience—they are
fundamental to clean, scalable, and maintainable software development.
 Assignment – 02

Q1. Elaborate on Python’s memory management. How does Python

handle object storage, reference counting, and garbage collection?

Ans.

Python’s Memory Management System

Python is a high-level language, and one of its powerful features is

automatic memory management. This means the programmer doesn’t
have to manually allocate or free memory—Python does it behind the
scenes. The system is efficient, robust, and designed to prevent memory
leaks and fragmentation.

1. Object Storage in Python

In Python, everything is an object—including integers, strings,

functions, and even types themselves. Each object is stored in memory
with associated information, including:

 Type: What kind of object it is (e.g., int, list, dict).

 Value: The actual data stored.

 Reference Count: The number of variables or containers

referencing the object.

 Memory Address: Where the object resides in memory.

Python uses a private heap space for storing all objects and data
structures. The management of this heap is handled by the Python
Memory Manager.

2. Reference Counting

One of the core mechanisms of memory management in Python is

reference counting.
What is Reference Counting?

Each object in Python maintains a count of how many references point to

it. When a new reference is created (for example, by assigning the object
to another variable), the count increases. When a reference is deleted or
goes out of scope, the count decreases.

 When the reference count drops to zero, it means no one is

using the object, and it becomes eligible for garbage collection.

 This is managed automatically by Python’s interpreter using

internal counters.

Advantages of Reference Counting:

 Simple and immediate deallocation of unused objects.

 Reduces memory wastage.

Limitations:

 Cannot handle cyclic references, i.e., objects referencing each

other in a loop, even if they're no longer in use.

3. Garbage Collection in Python

To overcome the limitations of reference counting (especially for cyclic

references), Python also uses an automatic garbage collector (GC).

Python’s Garbage Collector:

Python’s GC is part of the gc module, and it supplements reference

counting by detecting and cleaning up objects involved in reference
cycles.

How it Works:

 Python uses a technique called Generational Garbage Collection.

 Objects are divided into three generations (0, 1, and 2) based on

their lifespan:

o Generation 0: Newly created objects.

o Generation 1: Objects that survived one collection.

o Generation 2: Long-lived objects.

 The collector runs more frequently on younger generations, as most

objects die young.
  If an object survives multiple garbage collection cycles, it is
promoted to an older generation.

When is Garbage Collection Triggered?

 Automatically after a certain number of object allocations and

deallocations.

 Manually using functions from the gc module (like gc.collect()).

Significance:

 Handles cyclic garbage, which cannot be reclaimed by reference

counting alone.

 Frees up memory, improving performance and reducing the chance

of memory leaks.

Additional Concepts in Python Memory Management

Memory Pools (PyMalloc):

Python uses its own memory allocator called PyMalloc, which optimizes
memory usage for small objects by managing memory in blocks and
pools.

Interning:

For performance, Python may intern certain immutable objects like small
integers and strings. This means they are stored in a global table to avoid
multiple copies of the same object.

Conclusion

Python’s memory management is a sophisticated system combining heap

allocation, reference counting, and garbage collection. It abstracts
the complexities of memory handling from the programmer, making
development easier and more secure. While reference counting
ensures real-time object cleanup, garbage collection handles more
complex memory scenarios, like circular references. Together, these
mechanisms ensure that Python programs are memory-efficient and
reliable over long-term use.
Q2. Explain object-oriented programming in Python. Describe how Python
supports classes, inheritance, and polymorphism with real-life analogies.

Ans.

Object-Oriented Programming (OOP) in Python

Definition:

Object-Oriented Programming (OOP) is a programming paradigm

centered around the concept of "objects," which bundle data
(attributes) and behavior (methods) together. Python fully supports
OOP, making it easier to model real-world systems, enhance code
reusability, and maintain large applications.

Core Concepts of OOP in Python

1. Classes and Objects

 A class is like a blueprint or template for creating objects. It

defines what attributes (data) and methods (functions) the objects
will have.

 An object is an instance of a class, representing a specific entity

with unique values.

Real-Life Analogy:

Think of a class as a “Car Design”, which defines attributes like color,

engine, and speed, and behaviors like drive and brake. An object is an
actual car (like a red Toyota) built using that design. Many cars (objects)
can be created from the same class (blueprint), each with its own identity.
2. Inheritance

 Inheritance allows one class (child or subclass) to inherit properties

and behaviors from another class (parent or superclass).

 This promotes code reuse, since common functionality can be

written once in the parent class and reused or extended in child
classes.

Real-Life Analogy:

Imagine a “Vehicle” class as the parent, and “Car”, “Bike”, and

“Truck” as child classes. All vehicles share common features like engine
and wheels, but each subclass can have unique behaviors (like a truck
having a cargo area).

3. Polymorphism

 Polymorphism means "many forms". It allows objects of different

classes to be treated as objects of a common superclass.

 In Python, this is typically implemented through method

overriding and dynamic method dispatch, meaning the same
method name can behave differently depending on the object that
calls it.

Real-Life Analogy:

Consider the action “drive”:

 A bike drives differently than a car, and a car drives differently than
a truck.

 Yet, when you say “drive,” each vehicle understands what to do in

its own way. This is polymorphism—same interface, different
behavior.

Other Supporting OOP Features in Python

 Encapsulation: Bundles data and methods into a class and restricts

direct access to some components (using private or protected
members).

 Abstraction: Hides complex implementation details and shows only

the necessary parts to the user (like using a TV remote without
knowing its inner circuitry).
Benefits of Using OOP in Python

 Modularity: Code is organized into objects and classes.

 Reusability: Inherited classes reuse code from parent classes.

 Maintainability: Easier to update, scale, or debug due to logical

separation.

 Real-World Modeling: OOP is more intuitive when modeling real

systems or business processes.

Conclusion

Python's object-oriented features like classes, inheritance, and

polymorphism make it a powerful tool for writing scalable and
maintainable applications. With real-life analogies like cars, vehicles, and
driving, we can clearly see how OOP helps model and structure code
logically. These principles enable developers to build robust, reusable, and
well-structured programs that mirror the complexity of the real world.
Q3. What are exceptions in Python? Explain the concept of exception
handling and its role in building reliable applications. Discuss built-in
exceptions and the process of raising and handling custom exceptions.

Ans.

Exceptions in Python

Definition:

An exception in Python is an error that occurs during the execution of a

program. Unlike syntax errors, exceptions occur at runtime and interrupt
the normal flow of the program if not handled properly.

Example (conceptual):

Trying to divide a number by zero or accessing a file that doesn't exist will
raise an exception.

Concept of Exception Handling

What is Exception Handling?

Exception handling is a mechanism in Python to detect, catch, and

respond to runtime errors gracefully, without crashing the program.

Python uses the try-except block to handle exceptions. This allows

developers to anticipate possible errors and define alternate flows,
improving user experience and program stability.

Key Components:

 try block: Code that might raise an exception.

  except block: Code that handles the exception.

 else block: Code that runs if no exception occurs.

 finally block: Code that runs no matter what (usually for cleanup).

Role in Building Reliable Applications

1. Prevents Program Crashes

Uncaught exceptions terminate programs. Exception handling prevents

abrupt exits by catching and managing errors.

2. Enhances User Experience

Instead of cryptic error messages, users get meaningful feedback, such as

"File not found" or "Invalid input."

3. Enables Defensive Programming

Anticipating and handling edge cases and invalid conditions makes code
robust, especially in real-world applications involving user input, file
operations, or network communication.

4. Ensures Resource Management

The finally block ensures that resources like files and network connections
are properly closed, even if an error occurs.

Built-in Exceptions in Python

Python provides a rich set of built-in exceptions to represent common

error types. Some of them include:

Exception
Description
Name

ZeroDivisionErr
Raised when dividing by zero
or
Exception
Description
Name

Raised when a function receives the wrong type of

ValueError
argument

Raised when an operation is applied to an

TypeError
inappropriate type

IndexError Raised when accessing an invalid list index

KeyError Raised when a dictionary key is not found

FileNotFoundErr Raised when a file operation fails due to a missing

or file

ImportError Raised when a module or object can't be imported

AttributeError Raised when an invalid attribute is accessed

These are automatically raised by Python when something goes wrong.

Raising and Handling Custom Exceptions

1. Raising Exceptions

Python allows developers to raise exceptions manually using the raise

keyword. This is useful when we want to enforce certain rules or
validations in our application.

2. Creating Custom Exceptions

Custom exceptions are user-defined classes that inherit from Python’s

built-in Exception class. These are used when we want to represent
domain-specific errors that are not covered by built-in exceptions.

Why Use Custom Exceptions?

 To make error messages more specific and meaningful

 To differentiate between errors with the same built-in exception

class

 To implement business logic validations (e.g., “InvalidAgeError” for

age-restricted registrations)

Conclusion
Exceptions are an essential part of reliable software development.
Python’s structured and flexible exception handling system allows
developers to write robust applications that can deal with unexpected
situations without breaking. Built-in exceptions cover most common
errors, while custom exceptions offer precision and control in
specialized use-cases. Mastering exception handling in Python leads to
cleaner, more professional, and fault-tolerant code.