🔸 What is a Package?

• A package is a folder that contains Python files (modules).
• It helps you organize your code.
• You can reuse the code in many projects.

✅ Why Use Packages?

• Keeps your code clean and structured
• Makes code reusable
• Easy to share with others

🧳 Step-by-Step: Create Your Own Python Package

🔹 Step 1: Create Folder Structure

Let’s say you want a package named mymath.

mymath/
│
├── __init__.py
├── add.py
└── multiply.py

✅ __init__.py makes this folder a package.

🔹 Step 2: Write Module Files

📄 add.py:

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

📄 multiply.py:

def multiply(a, b):
    return a * b

📄 __init__.py:

from .add import add
from .multiply import multiply

🔹 Step 3: Use the Package in Your Code

Create a new file outside the folder (for example: main.py)

📄 main.py:

from mymath import add, multiply

print(add(2, 3))        # Output: 5
print(multiply(2, 3))   # Output: 6

✅ Now your package is working!

🔹 Step 4 (Optional): Add __all__ in __init__.py

This helps when you use from mymath import *

__all__ = ['add', 'multiply']

✅ Practice Time

Q1: Create a package called greet with:

• hello.py: hello(name) → prints “Hello, [name]”
• bye.py: bye(name) → prints “Goodbye, [name]”

Answer:

Folder:

greet/
├── __init__.py
├── hello.py
└── bye.py

📄 hello.py:

def hello(name):
    print(f"Hello, {name}")

📄 bye.py:

def bye(name):
    print(f"Goodbye, {name}")

📄 __init__.py:

from .hello import hello
from .bye import bye

Use it in main.py:

from greet import hello, bye

hello("John")
bye("John")

📦 Bonus: Make it Installable (Advanced)

To share with others (like on PyPI), create a setup.py:

from setuptools import setup, find_packages

setup(
    name='mymath',
    version='0.1',
    packages=find_packages()
)

Then run:

python setup.py install

🧾 Summary

🧠 Final Tip:

You can create your own Python tools using packages.
Perfect for organizing large projects!

🔹 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.