🔹 What is a Python Library or Package?

• A library is a group of ready-made code that helps you do tasks easily.
• A package is a folder that contains many libraries or modules.

✅ You don’t need to write everything from scratch. Just import and use!

🔸 How to Install a Library?

pip install library_name

Example:

pip install numpy

🔹 Most Popular Python Libraries by Category

📊 1. Data Analysis & Math

✅ Example:

import numpy as np

a = np.array([1, 2, 3])
print(a * 2)  # Output: [2 4 6]

🤖 2. Machine Learning

✅ Example:

from sklearn.linear_model import LinearRegression
model = LinearRegression()

🌐 3. Web Development

✅ Flask Example:

from flask import Flask
app = Flask(__name__)

@app.route('/')
def home():
    return "Hello, World!"

🧪 4. Testing & Automation

✅ Selenium Example:

from selenium import webdriver
driver = webdriver.Chrome()
driver.get("https://google.com")

🧰 5. Utilities & Tools

✅ Example:

import os
print(os.getcwd())  # Show current folder

📚 6. Web Scraping

✅ Example:

import requests
from bs4 import BeautifulSoup

r = requests.get("https://example.com")
soup = BeautifulSoup(r.text, 'html.parser')
print(soup.title.text)

🖼️ 7. Image and Media

✅ Example:

from PIL import Image
img = Image.open("image.jpg")
img.show()

🐍 8. GUI (Desktop Apps)

✅ Tkinter Example:

import tkinter as tk
win = tk.Tk()
win.title("Hello App")
win.mainloop()

🧾 Summary Table

🧠 Final Tip:

Learn the library you need for your project.
You don’t have to learn all at once.

📣 Coming Up Next:

➡️ How to Create Your Own Python Package (Step-by-Step)

🔸 Let’s Understand Both:

🔹 Example of Abstraction:

from abc import ABC, abstractmethod

class Payment(ABC):
    @abstractmethod
    def pay(self):
        pass

class UPI(Payment):
    def pay(self):
        print("Payment using UPI")

p = UPI()
p.pay()

✅ The user only knows they are using UPI. How it works inside is hidden.

🔹 Example of Encapsulation:

class Student:
    def __init__(self):
        self.__marks = 0  # private variable

    def set_marks(self, m):
        self.__marks = m

    def get_marks(self):
        return self.__marks

s = Student()
s.set_marks(95)
print(s.get_marks())  # Output: 95

✅ The marks are protected. We use methods to access them.

🧾 Summary Table

🧠 Easy Tip to Remember

• 🔍 Abstraction = “Don’t show how it works” (Focus on What)
• 🔒 Encapsulation = “Don’t let others touch my data” (Focus on How safe)

🎯 Recap in 2 Lines:

• Abstraction hides logic
• Encapsulation hides data

Both help you write clean and secure code.

🔹 What is Abstraction?

Abstraction means:

Hiding the complex details and showing only the important parts.

It helps us to:

• Focus on what an object does
• Not worry about how it does it

🔸 Real-Life Example:

Think about a TV remote:

• You press the power button to turn on the TV.
• You don’t need to know how electricity flows inside.

🟢 This is abstraction — showing only the button (interface), hiding the working inside.

🔹 Abstraction in Python

We use:

• Abstract Base Class (ABC)
• The abc module

🔹 How to Use Abstraction in Python

1. Import ABC and abstractmethod
2. Create a class that inherits from ABC
3. Use @abstractmethod to define abstract methods
4. Subclass must override these methods

🔹 Example:

from abc import ABC, abstractmethod

class Animal(ABC):  # Abstract class
    @abstractmethod
    def sound(self):  # Abstract method
        pass

class Dog(Animal):
    def sound(self):
        print("Dog barks")

class Cat(Animal):
    def sound(self):
        print("Cat meows")

d = Dog()
c = Cat()
d.sound()
c.sound()

🟢 Output:

Dog barks
Cat meows

🔹 Key Rules of Abstraction:

• You cannot create an object of abstract class.
• Child class must implement (override) abstract methods.
• Abstract class can also have normal methods.

🔹 Abstract Class with Normal Method

from abc import ABC, abstractmethod

class Vehicle(ABC):
    @abstractmethod
    def start(self):
        pass

    def fuel_type(self):
        print("Fuel type is petrol")

class Car(Vehicle):
    def start(self):
        print("Car is starting...")

c = Car()
c.start()
c.fuel_type()

📝 Practice Questions with Answers

❓ Q1: Create an abstract class Shape with abstract method area(). Implement it in Rectangle and Circle.

✅ Answer:

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Rectangle(Shape):
    def area(self):
        print("Area = length × width")

class Circle(Shape):
    def area(self):
        print("Area = π × radius²")

r = Rectangle()
c = Circle()
r.area()
c.area()

❓ Q2: Make an abstract class Device with turn_on() and turn_off() methods.

✅ Answer:

from abc import ABC, abstractmethod

class Device(ABC):
    @abstractmethod
    def turn_on(self):
        pass

    @abstractmethod
    def turn_off(self):
        pass

class Laptop(Device):
    def turn_on(self):
        print("Laptop is turning on")

    def turn_off(self):
        print("Laptop is shutting down")

l = Laptop()
l.turn_on()
l.turn_off()

🧾 Summary Table

🎯 Quick Recap

• Abstraction = Hiding details, showing only the essentials.
• Use abc module, ABC, and @abstractmethod.
• Helps write clean, structured, and safe code.

📣 Coming Up Next:

➡️ Difference Between Abstraction and Encapsulation in Python (Simple Words)

🔹 What is Method Overriding?

Method Overriding means:

A child class (subclass) writes its own version of a method that already exists in the parent class (superclass).

• It helps the child class change or improve the behavior of a parent method.
• The method name must be same in both classes.

🔸 Real-Life Example:

Imagine a general printer prints in black & white. But a color printer overrides that function and prints in color.

🔹 Basic Example of Method Overriding:

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):  # Overriding the parent's method
        print("Dog barks")

d = Dog()
d.speak()  # Output: Dog barks

✅ Dog class has its own version of the speak() method.

🔹 Why Use Method Overriding?

✅ To customize behavior
✅ To add extra work in child class
✅ To make code flexible and clean

🔹 Calling Parent Method Using super()

Sometimes we want to call the original (parent) method also:

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        super().speak()  # Call parent method
        print("Dog barks")

d = Dog()
d.speak()

🟢 Output:

Animal speaks
Dog barks

🔹 Another Example: Bank Account

class Account:
    def show_balance(self):
        print("Balance is $1000")

class SavingsAccount(Account):
    def show_balance(self):
        print("Savings balance is $1500")

a = SavingsAccount()
a.show_balance()

📝 Practice Questions with Answers

❓ Q1: Create a class Shape with a method draw(). Override it in Circle and Square.

✅ Answer:

class Shape:
    def draw(self):
        print("Drawing a shape")

class Circle(Shape):
    def draw(self):
        print("Drawing a circle")

class Square(Shape):
    def draw(self):
        print("Drawing a square")

c = Circle()
s = Square()

c.draw()
s.draw()

❓ Q2: Create a class Employee with method work(). Override it in Manager and Developer.

✅ Answer:

class Employee:
    def work(self):
        print("Employee works")

class Manager(Employee):
    def work(self):
        print("Manager manages the team")

class Developer(Employee):
    def work(self):
        print("Developer writes code")

m = Manager()
d = Developer()

m.work()
d.work()

🧾 Summary

🎯 Quick Recap

• Method Overriding = Changing a parent method in the child class.
• Useful when child class needs a different behavior.
• super() helps to use parent’s method with the new one.

🔹 What is Polymorphism?

The word Polymorphism means:

Poly = many, morph = form
So, Polymorphism = many forms

📌 In Python, the same function or method can work in different ways depending on the object.

🔹 Why Use Polymorphism?

✅ Makes code flexible
✅ Easy to understand and update
✅ Helps work with different objects in a similar way

🔹 Example: Polymorphism with Functions

def add(a, b):
    return a + b

print(add(3, 4))        # Numbers
print(add("Hi ", "Tom"))  # Strings

✅ Same function name add() works with numbers and strings — this is polymorphism.

🔹 Polymorphism with Classes

Let’s see two different classes using the same method name:

class Dog:
    def speak(self):
        print("Dog barks")

class Cat:
    def speak(self):
        print("Cat meows")

def animal_sound(animal):
    animal.speak()

d = Dog()
c = Cat()

animal_sound(d)
animal_sound(c)

✅ Different objects (Dog, Cat) use the same method speak() in different ways.

🔹 Polymorphism with Inheritance

class Vehicle:
    def move(self):
        print("Vehicle is moving")

class Car(Vehicle):
    def move(self):
        print("Car is driving")

class Boat(Vehicle):
    def move(self):
        print("Boat is sailing")

def start_trip(vehicle):
    vehicle.move()

v1 = Car()
v2 = Boat()

start_trip(v1)
start_trip(v2)

✅ move() method works differently for each object. This is runtime polymorphism.

🔹 Built-in Polymorphism Example

print(len("Python"))       # Output: 6
print(len([1, 2, 3, 4]))    # Output: 4
print(len((10, 20, 30)))    # Output: 3

✅ len() function works with string, list, tuple — same function name, many forms.

📝 Practice Questions with Answers

❓ Q1: Create a method called greet() in two classes: English and Spanish.

✅ Answer:

class English:
    def greet(self):
        print("Hello")

class Spanish:
    def greet(self):
        print("Hola")

def say_hello(obj):
    obj.greet()

e = English()
s = Spanish()
say_hello(e)
say_hello(s)

❓ Q2: Write a function that accepts any shape class and prints area using area() method.

✅ Answer:

class Circle:
    def area(self):
        print("Area of Circle: πr²")

class Square:
    def area(self):
        print("Area of Square: side²")

def print_area(shape):
    shape.area()

c = Circle()
s = Square()
print_area(c)
print_area(s)

🧾 Summary Table

🎯 Quick Recap

• Polymorphism helps the same method name work in different ways.
• It can be seen in:
  • Functions
  • Classes
  • Inheritance
  • Built-in functions