NAME = Syamantok Saha

ROLL NO = 23BEC076

BRANCH = ECE

BATCH = DIV-2, F-3

SUBJECT = PYTHON LAB

LAB FILE - 1

QUESTION-1
1. Discuss their programming background. Which languages do they know? Did they
know/participating in any programming competitions such as hacker rank?
Ans: Python holds immense importance in undergraduate programs due to its versatility,
simplicity, and widespread adoption in various fields. Its readability and ease of learning
make it an ideal choice for beginners, enabling students to grasp fundamental
programming concepts effectively. Moreover, Python’s extensive libraries and
frameworks support diverse applications, including data science, web development,
artificial intelligence, and more, aligning with the current industry demands. The
language’s popularity stems from its robust community support, scalability, and cross-
platform compatibility, making it a preferred choice for both educational and
professional purposes. Mastering Python equips students with valuable skills that are
highly sought after in the job market, making it a valuable asset for their academic and
future career endeavours.

QUESTION-2
2. Discuss why python is important to learn for their UG program? Significance of
python. Why python is popular nowadays.
Ans: Python is crucial for undergraduate programs because it's easy to learn, versatile,
and widely used across industries. Its simplicity, rich libraries, community support, and
job opportunities make it an essential skill for students. Python's popularity stems from
its easy learning curve, versatility for various applications, extensive library support,
strong community.
QUESTION-3
3. Introduce them Python Platform (Python Integrated Development Environment).
How it works. Two modes of the platform (GUI, command prompt).
Ans: Python Integrated Development Environment (IDE) is a software application that
provides comprehensive facilities to programmers for software development. It offers
features like code editing, debugging, and execution within a single interface. In the GUI
mode, the IDE provides a graphical user interface where developers can write, edit, and
run Python code efficiently. On the other hand, the command prompt mode allows
users to interact with Python through a command-line interface, providing a more direct
and text-based approach to coding. Both modes have their advantages based on the
developer’s preference and the nature of the project. The GUI mode is user-friendly and
visually interactive, while the command prompt mode offers a more streamlined and
text-focused coding experience. Python IDEs like PyCharm, VS Code, and Jupiter
Notebook are popular choices among developers for their robust features and ease of
use.

QUESTION-4
4. Discuss the alternatives of python (such as R language).
Ans: When considering alternatives to Python, the R language stands out as a powerful
option, particularly in the realm of statistical computing and data analysis. R is renowned
for its extensive libraries and packages tailored for statistical modelling, visualization, and
machine learning. While Python offers versatility across various domains due to its
general-purpose nature, R excels in statistical tasks, making it a preferred choice for
statisticians and data scientists. Both languages have vibrant communities and strong
support, with Python being more versatile for broader applications beyond statistics.
Ultimately, the choice between Python and R depends on the specific requirements of
the project and the expertise of the user.
QUESTION-5
5. Discuss the Course Syllabus, Prerequisites for the Course, Teaching Scheme, List of
Books and Reference Books.
Ans: Python, with its versatility and ease of use, finds applications in various real-life
scenarios. For instance, in data analysis, Python’s libraries like Pandas and NumPy are
extensively used to process and analyse large datasets efficiently. Moreover, in web
development, frameworks like Django and Flask enable developers to build robust web
applications quickly.
Python also plays a significant role in automation tasks. For example, in the finance
sector, Python scripts are utilized for automating repetitive financial calculations and
generating reports. Additionally, in the field of machine learning and artificial intelligence,
Python’s libraries such as TensorFlow and scikit-learn are pivotal for developing advanced
algorithms. In essence, Python’s widespread adoption across industries showcases its
practicality and effectiveness in solving real- world problems.

QUESTION-6
6. Discuss the alternative online python programming platforms (such as Google
Colab, Online Python compilers etc).
Ans: There are several alternative online Python programming platforms available for
users looking to code without setting up a local environment. Google Collab is a popular
choice that offers a Jupyter notebook environment with free access to GPUs. Online
Python compilers like Repl.it and Ide one provides a quick way to run Python code
directly in the browser. Additionally, platforms like PythonAnywhere offer online Python
development environments with features for web hosting and scheduled tasks. Each
platform has its unique features and benefits, catering to different needs and
preferences of Python developers.
QUESTION-8
8. Discuss simple case-study on applications of python in real-life.
Ans: Case Study: Automated Email Scheduler • Problem: Sending regular emails to
clients manually is time consuming and error-prone. • Solution: a.
Data Preparation: Store client information in a CSV file. b. Email Template:
Create a template with placeholders for client-specific details. c. Python Script: Use
Python to read client data, generate personalized emails, and send them automatically.
d. Scheduling: Use Python libraries like `schedule` to schedule the script's execution at
regular intervals. • Benefits: Saves time, reduces errors, and ensures timely
communication with clients.

QUESTION-9
9. Can introduce them elementary operations such as +, -, *, /, % etc python command
prompt.
Ans:
QUESTION-10
OUESTION-11
LAB FILE - 2

QUESTION-1

QUESTION-2
QUESTION-3
QUESTION-4

QUESTION-5
LAB FILE - 3

QUESTION-1
QUESTION-2

QUESTION-3
QUESTION-4
LAB FILE - 4
QUESTION-1
QUESTION-2
QUESTION-4
QUESTION-5
LAB FILE - 5
QUESTION-1

QUESTION-2
QUESTION-3
QUESTION-4
QUESTION-5
LAB FILE – 6
QUESTION-1

QUESTION-2
QUESTION-3
QUESTION-4
QUESTION-5

QUESTION-6
LAB FILE – 7
QUESTION-1
QUESTION-2

QUESTION-3
QUESTION-4
QUESTION-5
LAB FILE – 8

QUESTION-1
1. WAP with class Person definition. Demonstrate the use of following
concepts of object-oriented python through your program.
Object creation
encapsulation
_init_ ()
_str_ ()

Code:
class person:
def init (self, name, age):
self.name=name
self.age=age

def intro(self):
return 'hello my name is ' + self.name + ' and i am ' +
str(self.age)

p=person ("Vini", 19) print (p. intro ()) Output:

2. Inherit class Person in class student. Demonstrate the use of super () and
define a method to demonstrate method overriding.

Code:
class person:
def init (self):
self.value="inside person"

def show(self): print(self.value)

class student(person):
def init (self):
self.value="inside student"

def show(self): print(self.value)

a=person () b=student () a.show ()
b.show ()
Output:
3. Create a class “Employee” with a function “hello_employee ()”. Now,
create an object of the class and demonstrate the function overloading.
When “hello_employee ()” is called without any argument (e.g., none), it
should print only “Hello”, else when called with employee name as
argument, it should print “Hello $Employee Name$”. (Concept: Method
Overloading)

Code:
class employee:
def hello_employee (self, name=None):
if name is None:
print("hello")
else:
print (f"hello {name}")

emp=employee () emp. hello_employee ()

emp. hello_employee("Vini")
Output:
LAB FILE – 9

QUESTION-1
QUESTION-2

2. Create a class “Animal” with attribute “name” and a function “eat ()”.
Now, create another class “Dog”, which inherit the “Animal” class. The
“Dog” class will have a method “Display ()” to print “My name is
$dog_name$”. The eat () method of “Animal” class will print a message “I
can eat”. Now, demonstrate the inheritance by creating an object of class
“Dog”, which will inherit the attribute “name” and method “eat” of
“Animal” class.

Code:
class animal:

def init (self, name):

self.name = name

def eat(self):
print ("I can eat")

class cat(animal): def display(self):

print (f"My name is {self.name}")

class dog(animal): def display(self):

print (f"My name is {self.name}")

cat = cat("furball") dog = dog("oreo") cat. display () cat. eat ()

dog. display ()
dog.eat ()
Output:

QUESTION-3

3. Explain the concept of multiple Inheritance with suitable example.

Multiple inheritance is a feature of object-oriented programming languages

that allows a class to inherit attributes and methods from more than one
parent class. This means that a subclass can inherit behaviors and properties
from multiple parent classes.

Example: class Animal:

def init (self, name):

self.name = name
def speak(self):
raise NotImplementedError ("Subclass must implement
abstract method")

class Dog (Animal):

def speak(self): return "Woof!"

class Cat (Animal): def speak(self): return "Meow!"

class DogCat (Dog, Cat): def init (self, name):

# Multiple inheritance calls for super () might need special care, as the order
matters.

# This example simplifies the behavior to avoid such issues. Super (). init
(name)

pet = DogCat("buddy")
print (pet. Speak ())

Output:
The DogCat class demonstrates multiple inheritance by inheriting from both
Dog and Cat. It inherits the speak method from both parent classes, so when
we create an instance of DogCat and call speak (), it returns "Woof!" because
Dog is listed first in the inheritance list.

4. Explain the concept of multi-level Inheritance with suitable example.

Multi-level inheritance is a feature of object-oriented programming

languages that allows a class to inherit attributes and methods from a parent
class, and then further extend that inheritance to a new subclass. This
creates a hierarchy of classes where each subclass inherits from its
immediate parent class.

Example: class animal:

def init (self, name):

self.name = name

def speak(self):
raise NotImplementedError ("Subclass must implement
abstract method")

class dog(animal):
def speak(self): return "Woof!"

class labrador(dog):

def init (self, name, color):

super (). init (name)
self. color = color

def fetch(self):
return "fetching..."
mylab= labrador ("buddy", "golden") print(mylab.name) print (mylab. color)
print (mylab. speak ())
print (mylab. Fetch ())

Output:

The Animal class is the base class with a name attribute and a speak method.
The Dog class inherits from Animal and implements its own speak method to
return "Woof!". The Labrador class then further extends the Dog class,
inheriting both the speak method from Dog and the name attribute from
Animal. Additionally, Labrador introduces a new attribute color and a new
method fetch.