🔥 DAY 5 – Conditional Statements (if, else, elif) 🔥
Today we learn how Python makes decisions 🧠
👉 Simply: Conditions = “If this happens → do this”


⸻


✨ 1. if Statement (Basic decision)

x = 10  

if x > 5:  
    print("x is greater than 5")


👉 Meaning:
If condition is TRUE → code runs ✅


⸻


✨ 2. if-else (Two choices)

x = 3  

if x > 5:  
    print("Greater")  
else:  
    print("Smaller")


👉 Meaning:
If TRUE → first block
If FALSE → else block


⸻


✨ 3. if-elif-else (Multiple conditions)

x = 0  
if x > 0:  
    print("Positive")  
elif x == 0:  
    print("Zero")  
else:  
    print("Negative")


👉 Meaning:
Checks conditions one by one


⸻


✨ 4. Nested if (if inside if)

x = 10  

if x > 5:  
    if x < 20:  
        print("Between 5 and 20")


👉 Meaning:
Condition inside another condition


⸻


✨ 5. Short Hand if (One line)

x = 10  
if x > 5: print("Greater")



⸻


✨ 6. Short Hand if-else (Ternary)

x = 10  
print("Big") if x > 5 else print("Small")

⸻


💻 Practice here:
https://www.mycompiler.io/online-python-compiler


⸻


🚀 Follow for more: https://t.me/futurestack45

🔥 Learn Daily | Grow Daily | Become Developer

📘 Day 6 – Nested If
👉 Definition: Nested If means using an if statement inside another if statement to check multiple conditions step by step.

⸻

💻 Code Example 1 (Copy this into Telegram)

age = 20
has_id = True

if age >= 18:
    if has_id:
        print("Allowed to enter")
    else:
        print("ID required")
else:
    print("Underage")


👉 Meaning: If age ≥ 18 → then check ID If both TRUE → Allowed ✅

⸻

💻 Code Example 2

num = 10

if num > 0:
    if num % 2 == 0:
        print("Positive Even")
    else:
        print("Positive Odd")
else:
    print("Negative number")


👉 Meaning: First check Positive → then Even/Odd

⸻

💻 Code Example 3

marks = 75

if marks >= 50:
    if marks >= 75:
        print("Distinction")
    else:
        print("Pass")
else:
    print("Fail")


👉 Meaning: Pass → then check Distinction

⸻

🧠 Key Points
✔ Used for multiple condition checking ✔ Helps in step-by-step decisions ✔ Too many nested ifs → makes code complex ❌

⸻

🎯 Practice
# 1. Check if number is positive AND divisible by 5

# 2. Check if age > 18 AND has license

# 3. Simple login system using nested if

⸻

🔥 Better Alternative (Avoid Deep Nesting)

age = 20
has_id = True

if age >= 18 and has_id:
    print("Allowed")
else:
    print("Not allowed")

💻 Practice here:
https://www.mycompiler.io/online-python-compiler

⸻

🚀 Follow for more: https://t.me/futurestack45

🔥 Learn Daily | Grow Daily | Become Developer

Will start posting Python content from tomorrow onwards 📌

Follow : https://t.me/futurestack45

📘 Day 7 – For Loop
👉 Definition: A for loop is used to repeat a block of code multiple times.
👉 It is mainly used to iterate over a sequence (like list, string, range).

⸻

💻 Code Example 1 (Basic Loop)

for i in range(5):
    print(i)


👉 Meaning: Prints numbers from 0 to 4

⸻

💻 Code Example 2 (Start & End)

for i in range(1, 6):
    print(i)


👉 Meaning: Prints numbers from 1 to 5

⸻

💻 Code Example 3 (Step Value)

for i in range(1, 10, 2):
    print(i)


👉 Meaning: Prints: 1, 3, 5, 7, 9

⸻

💻 Code Example 4 (Loop with List)

fruits = ["apple", "banana", "mango"]

for fruit in fruits:
    print(fruit)


👉 Meaning: Prints each item from the list

⸻

💻 Code Example 5 (Loop with String)

for char in "Python":
    print(char)


👉 Meaning: Prints each character

⸻

💻 Code Example 6 (With Condition)

for i in range(1, 6):
    if i == 3:
        print("Found 3")
    else:
        print(i)


👉 Meaning: Checks condition inside loop

⸻

🧠 Key Points
✔ Used for repeating tasks ✔ range() is commonly used ✔ Can loop through list, string, etc

⸻

🎯 Practice
# 1. Print numbers from 1 to 10
# 2. Print even numbers from 1 to 20
# 3. Print each character in your name
# 4. Print table of 5

⸻

🔥 Pro Tip
👉 Use loops to: ✔ Automate tasks ✔ Work with data ✔ Build logic

📢 Follow for more: https://t.me/futurestack45

📘 Day 8 – While Loop
👉 Definition: A while loop is used to repeat a block of code as long as a condition is TRUE.
👉 It runs until the condition becomes FALSE.

⸻

💻 Code Example 1 (Basic While Loop)

i = 1

while i <= 5:
    print(i)
    i += 1


👉 Meaning: Prints numbers from 1 to 5

⸻

💻 Code Example 2 (Condition Based Loop)

num = 1

while num < 10:
    print(num)
    num += 2


👉 Meaning: Prints: 1, 3, 5, 7, 9

⸻

💻 Code Example 3 (Infinite Loop ⚠️)

while True:
    print("Hello")


👉 Meaning: Runs forever (until manually stopped)

⸻

💻 Code Example 4 (Using Break)

i = 1

while i <= 10:
    if i == 5:
        break
    print(i)
    i += 1


👉 Meaning: Stops loop when i = 5

⸻

💻 Code Example 5 (Using Continue)

i = 0

while i < 5:
    i += 1
    if i == 3:
        continue
    print(i)


👉 Meaning: Skips number 3

⸻

🧠 Key Points
✔ Runs based on condition ✔ Can become infinite if condition never becomes FALSE ❌ ✔ Always update variable inside loop

⸻

🎯 Practice
# 1. Print numbers from 1 to 10 using while

# 2. Print even numbers from 1 to 20

# 3. Print sum of numbers from 1 to 10

# 4. Reverse a number using while

⸻

🔥 Pro Tip
👉 Use while when: ✔ You don’t know how many times loop will run ✔ Condition-based repetition is needed

📢 Follow for more: https://t.me/futurestack45

📘 Day 9 – Break & Continue
👉 Definition: break and continue are used to control loops
break → completely stops the loop
continue → skips current iteration and moves to next

⸻

💻 Code Example 1 (Break)

for i in range(1, 6):
    if i == 3:
        break
    print(i)


👉 Meaning: Loop stops when i = 3 Output: 1, 2

⸻

💻 Code Example 2 (Continue)

for i in range(1, 6):
    if i == 3:
        continue
    print(i)


👉 Meaning: Skips 3 Output: 1, 2, 4, 5

⸻

💻 Code Example 3 (While + Break)

i = 1

while i <= 5:
    if i == 4:
        break
    print(i)
    i += 1


👉 Meaning: Stops loop when i = 4

⸻

💻 Code Example 4 (While + Continue)

i = 0

while i < 5:
    i += 1
    if i == 2:
        continue
    print(i)


👉 Meaning: Skips 2

⸻

🧠 Simple Understanding
👉 break = Stop loop immediately 🛑 👉 continue = Skip current step ⏭️

⸻

🎯 Practice
# 1. Print numbers 1–10 but stop at 6

# 2. Print numbers 1–10 but skip multiples of 3

# 3. Find first number divisible by 7 (use break)

⸻

🔥 Pro Tip
👉 Use: ✔ break → when condition is achieved ✔ continue → when you want to skip a value

DAY 10 – LISTS (Python Basics)

⸻

📌 What is a List? 👉 A list is a collection of items stored in a single variable 👉 It is ordered, changeable, and allows duplicates

⸻

📌 Example (Create List)

fruits = ["apple", "banana", "mango"]
print(fruits)


👉 Output:
['apple', 'banana', 'mango']

⸻

📌 Access List Items

fruits = ["apple", "banana", "mango"]
print(fruits[0])
print(fruits[1])


👉 Output:
apple
banana

⸻

📌 Change List Item

fruits = ["apple", "banana", "mango"]
fruits[1] = "orange"
print(fruits)


👉 Output:
['apple', 'orange', 'mango']

⸻

📌 Add Item (append)

fruits = ["apple", "banana"]
fruits.append("mango")
print(fruits)


👉 Output:
['apple', 'banana', 'mango']

⸻

📌 Remove Item

fruits = ["apple", "banana", "mango"]
fruits.remove("banana")
print(fruits)


👉 Output:
['apple', 'mango']

⸻

📌 List Length

fruits = ["apple", "banana", "mango"]
print(len(fruits))


👉 Output:
3

⸻

📌 Loop Through List

fruits = ["apple", "banana", "mango"]

for item in fruits:
    print(item)


👉 Output:
apple
banana
mango

⸻

🎯 🔥 Important Example (All Data Types in One List)

data = ["apple", 10, 3.5, True]
print(data)


👉 Output:
['apple', 10, 3.5, True]

👉 Meaning: ✔ String → “apple” ✔ Integer → 10 ✔ Float → 3.5 ✔ Boolean → True
👉 Python list can store multiple data types together ✅

⸻

💡 Summary ✔ Store multiple values in one variable ✔ Can store different data types ✔ Very useful in real-world coding

⸻

📢 Follow 👉 https://t.me/futurestack45 🔁 Share with friends to grow together 🚀

DAY 11 – TUPLES (Python Basics)

⸻

📌 What is a Tuple? 👉 A tuple is a collection of items stored in a single variable 👉 It is ordered, NOT changeable (immutable), allows duplicates

⸻

📌 Example (Create Tuple)

fruits = ("apple", "banana", "mango")
print(fruits)


👉 Output:
('apple', 'banana', 'mango')

⸻

📌 Access Tuple Items

fruits = ("apple", "banana", "mango")
print(fruits[0])
print(fruits[1])


👉 Output:
apple
banana
👉 Index starts from 0

⸻

📌 Tuple is Immutable ❌

fruits = ("apple", "banana", "mango")
fruits[1] = "orange"


👉 Output:
TypeError: 'tuple' object does not support item assignment
👉 Meaning: ❌ Cannot change values in tuple

⸻

📌 Tuple Length

fruits = ("apple", "banana", "mango")
print(len(fruits))


👉 Output:
3

⸻

📌 Loop Through Tuple

fruits = ("apple", "banana", "mango")

for item in fruits:
    print(item)


👉 Output:
apple
banana
mango

⸻

📌 Single Item Tuple (Important ⚠)

data = ("apple",)
print(type(data))


👉 Output:
<class 'tuple'>
👉 Without comma → it is NOT tuple ❌

⸻

🎯 🔥 Example (All Data Types in Tuple)

data = ("apple", 10, 3.5, True)
print(data)


👉 Output:
('apple', 10, 3.5, True)
👉 Meaning: ✔ String → “apple” ✔ Integer → 10 ✔ Float → 3.5 ✔ Boolean → True

⸻

💡 Summary ✔ Same as list but cannot change values ✔ Faster than list ✔ Used when data should not change

⸻

📢 Follow 👉 https://t.me/futurestack45
🔁 Share with friends to grow together 🚀

DAY 12 – DICTIONARIES (Python Basics)


⸻


📌 What is a Dictionary?
👉 A dictionary stores data in key : value pairs
👉 Each key is unique
👉 It is ordered & changeable


⸻


📌 Example (Create Dictionary)

student = {
    "name": "John",
    "age": 20,
    "marks": 85
}

print(student)


👉 Output:
{'name': 'John', 'age': 20, 'marks': 85}


⸻


📌 Access Values (Using Key)

student = {
    "name": "John",
    "age": 20
}

print(student["name"])
print(student["age"])


👉 Output:
John
20


⸻


📌 Change Value

student = {
    "name": "John",
    "age": 20
}

student["age"] = 25
print(student)


👉 Output:
{'name': 'John', 'age': 25}


⸻


📌 Add New Data

student = {
    "name": "John"
}

student["marks"] = 90
print(student)


👉 Output:
{'name': 'John', 'marks': 90}


⸻


📌 Remove Data

student = {
    "name": "John",
    "age": 20
}

student.pop("age")
print(student)


👉 Output:
{'name': 'John'}


⸻


📌 Loop Through Dictionary

student = {
    "name": "John",
    "age": 20
}

for key in student:
    print(key, student[key])


👉 Output:
name John
age 20


⸻


🎯 🔥 Important Example (All Data Types)

data = {
    "name": "Alice",
    "age": 25,
    "height": 5.5,
    "is_student": True
}

print(data)


👉 Output:
{'name': 'Alice', 'age': 25, 'height': 5.5, 'is_student': True}


⸻


🧠 Simple Understanding
👉 Dictionary = Real-life form 🧾
✔ Name → John
✔ Age → 20


⸻


💡 Summary
✔ Stores data in key-value format
✔ Fast access using keys
✔ Used in APIs, JSON, real apps


⸻


📢 Follow 👉 https://t.me/futurestack45

🔁 Share with friends to grow together 🚀

Starting Python From basics to learn it in 3 weeks ✅

Plan ✅

🟢 UNIT 1 – BASICS (Foundation)

👉 Day 1 – What is Python + Features
👉 Day 2 – Variables & Data Types
👉 Day 3 – Input & Output
👉 Day 4 – Operators

⸻

🟡 UNIT 2 – CONTROL FLOW (Logic Building)

👉 Day 5 – If / Else Conditions
👉 Day 6 – Nested If + Practice
👉 Day 7 – For Loop
👉 Day 8 – While Loop
👉 Day 9 – Break & Continue

⸻

🔵 UNIT 3 – DATA STRUCTURES

👉 Day 10 – Lists
👉 Day 11 – Tuples
👉 Day 12 – Dictionaries

Above are covered 🔥✅ 

—————————————————


👉 Day 13 – Sets

⸻

🟣 UNIT 4 – FUNCTIONS & LOGIC

👉 Day 14 – Functions Basics
👉 Day 15 – Function Arguments + Mini Project

⸻

🎯 BONUS (OPTIONAL – HIGH VALUE 🔥)

👉 Day 16 – File Handling
👉 Day 17 – Exception Handling
👉 Day 18 – OOP Basics

DAY 13 – SETS (Python Basics)

⸻

📌 What is a Set? 👉 A set is a collection of unique items 👉 It is unordered, unchangeable, and does NOT allow duplicates*
(You can add/remove items, but items themselves cannot be changed)

⸻

📌 Example (Create Set)

numbers = {1, 2, 3, 4}
print(numbers)


👉 Output:
{1, 2, 3, 4}

⸻

📌 Duplicate Values Not Allowed

data = {1, 2, 2, 3, 3}
print(data)


👉 Output:
{1, 2, 3}
👉 Meaning: duplicates are automatically removed ✅

⸻

📌 Add Item

numbers = {1, 2, 3}
numbers.add(4)
print(numbers)


👉 Output:
{1, 2, 3, 4}

⸻

📌 Remove Item

numbers = {1, 2, 3}
numbers.remove(2)
print(numbers)


👉 Output:
{1, 3}

⸻

📌 Loop Through Set

numbers = {1, 2, 3}

for item in numbers:
    print(item)


👉 Output:
1
2
3

⸻

📌 Set Length

numbers = {1, 2, 3}
print(len(numbers))


👉 Output:
3

⸻

🎯 🔥 Example (All Data Types in Set)

data = {"apple", 10, 3.5, True}
print(data)


👉 Output:
{'apple', 10, 3.5, True}

⸻

🧠 Simple Understanding 👉 Set = Collection of unique values only 👉 No duplicates allowed 🚫

⸻

💡 Summary ✔ Stores only unique values ✔ Unordered (no index) ✔ Useful for removing duplicates

⸻

📢 Follow 👉 https://t.me/futurestack45 🔁 Share with friends to grow together 🚀

Major Differences ✅

https://t.me/futurestack45

📅 Day 14: Functions in Python

🔹 Function Definition:
A function is a block of reusable code that performs a specific task. It helps in organizing code, improving readability, and avoiding repetition.

🔹 Syntax:
def function_name(parameters):
# code
return result

--------------------------------------------------

🔹 Example 1: Simple Function
def greet():
print("Hello, Welcome!")

greet()

Output:
Hello, Welcome!

--------------------------------------------------

🔹 Example 2: Function with Parameters
def add(a, b):
return a + b

result = add(3, 5)
print(result)

Output:
8

--------------------------------------------------

🔹 Example 3: Function with Default Parameter
def greet(name="User"):
print("Hello", name)

greet()
greet("John")

Output:
Hello User
Hello John

--------------------------------------------------

🔹 Example 4: Function with Return Value
def square(n):
return n * n

print(square(4))

Output:
16

--------------------------------------------------

🔹 Types of Functions in Python

1️⃣ Built-in Functions:
Definition: Predefined functions available in Python.
Example:
print("Hello")
len([1,2,3])

--------------------------------------------------

2️⃣ User-defined Functions:
Definition: Functions created by the user using 'def'.
Example:
def multiply(a, b):
return a * b

print(multiply(2,3))

Output:
6

--------------------------------------------------

3️⃣ Anonymous Functions (Lambda):
Definition: Small one-line functions without a name using 'lambda'.
Example:
square = lambda x: x * x
print(square(5))

Output:
25

--------------------------------------------------

4️⃣ Recursive Functions:
Definition: A function that calls itself.
Example:
def factorial(n):
if n == 1:
return 1
return n * factorial(n-1)

print(factorial(5))

Output:
120

--------------------------------------------------

5️⃣ Function with Multiple Arguments (*args):
Definition: Allows passing multiple non-keyword arguments.
Example:
def add_all(*numbers):
return sum(numbers)

print(add_all(1,2,3,4))

Output:
10

--------------------------------------------------

6️⃣ Function with Keyword Arguments (**kwargs):
Definition: Allows passing multiple keyword arguments.
Example:
def display(**data):
print(data)

display(name="John", age=25)

Output:
{'name': 'John', 'age': 25}

--------------------------------------------------

✅ Summary:
- Functions help reuse code
- Can take inputs (parameters)
- Can return outputs
- Different types improve flexibility

Day 15 – Lambda Functions & Map / Filter
🔹 Definition: Lambda is a small anonymous (one-line) function used for short operations without using def.

⸻

🔹 Example:

square = lambda x: x * x
print(square(5))


Output:
25
⸻

🔹 Lambda with Multiple Arguments:

add = lambda a, b: a + b
print(add(3, 7))

Output:

10

 
⸻
 
🔹 Using map() 👉 Applies function to all elements

nums = [1, 2, 3, 4]
result = list(map(lambda x: x*2, nums))
print(result)


Output:
[2, 4, 6, 8]

⸻

🔹 Using filter() 👉 Filters elements based on condition

nums = [1, 2, 3, 4, 5, 6]
result = list(filter(lambda x: x % 2 == 0, nums))
print(result)


Output:
[2, 4, 6]

⸻

🔹 map + filter Together:

nums = [1, 2, 3, 4, 5]

result = list(map(lambda x: x*2,
          filter(lambda x: x % 2 == 0, nums)))

print(result)


Output:
[4, 8]

⸻

❌ Common Mistake:

square = lambda x: x * x
print(square)


Output:
<function <lambda>>
❌ Forgot to pass value

⸻

✅ Summary: ✔ Lambda = one-line function ✔ No need of ‘def’ ✔ Best for quick operations ✔ Works with map() & filter() 🚀


📢 Follow 👉 https://t.me/futurestack45
🔁 Share with friends to grow together 🚀

Day 16 – File Handling in Python
🔹 Definition: File handling is used to read, write, and manage files in Python.

⸻

🔹 Opening a File:

file = open("test.txt", "r")
print(file.read())
file.close()


👉 Modes:
"r" → Read
"w" → Write (overwrite)
"a" → Append
"x" → Create

⸻

🔹 Reading a File:

file = open("test.txt", "r")
print(file.read())
file.close()


Output:
(Displays file content)

⸻

🔹 Writing to a File:

file = open("test.txt", "w")
file.write("Hello Python")
file.close()


👉 Output: File will contain → Hello Python

⸻

🔹 Appending to a File:

file = open("test.txt", "a")
file.write("\nWelcome")
file.close()


👉 Output: Adds content without deleting old data

⸻

🔹 Using with (Best Practice):

with open("test.txt", "r") as file:
    print(file.read())


👉 No need to close file manually ✅

⸻

🔹 Read Line by Line:

with open("test.txt", "r") as file:
    for line in file:
        print(line)



⸻

❌ Common Mistake:

file = open("test.txt", "r")
print(file.read())


❌ File not closed

⸻

✅ Summary: ✔ Used to handle files ✔ Modes: r, w, a, x ✔ Use with for safety ✔ Always close file or use with 🚀

📢 Follow 👉 https://t.me/futurestack45
🚀 Learn something new every day
💡 Upgrade your skills step by step

Day 17 – OOP (Object-Oriented Programming) Basics
🔹 Definition: OOP is a programming approach that organizes code using classes and objects, making it easier to structure, reuse, and manage.

⸻

🔹 Class (Blueprint) 👉 A class is a template used to create objects

class Student:
    pass



⸻

🔹 Object (Instance) 👉 An object is an instance created from a class

class Student:
    pass

s1 = Student()
print(type(s1))


Output:
<class '__main__.Student'>

⸻

🔹 Constructor (__init__) 👉 A special method that initializes object data when created

class Student:
    def __init__(self, name):
        self.name = name

s1 = Student("Mani")
print(s1.name)


Output:
Mani

⸻

🔹 Method (Function inside class) 👉 Defines behavior of an object

class Car:
    def start(self):
        print("Car started")

c1 = Car()
c1.start()


Output:
Car started

⸻

🔹 Inheritance 👉 A class can inherit properties and methods from another class

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

class Dog(Animal):
    pass

d = Dog()
d.sound()


Output:
Animal sound

⸻

🔹 Encapsulation 👉 Restricts direct access to data and protects it

class Bank:
    def __init__(self):
        self.__balance = 1000

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

b = Bank()
b.show()


Output:
1000

⸻

🔹 Polymorphism 👉 Same method name behaves differently for different objects

class Dog:
    def sound(self):
        print("Bark")

class Cat:
    def sound(self):
        print("Meow")

for animal in (Dog(), Cat()):
    animal.sound()


Output:
Bark
Meow

⸻

❌ Common Mistake:

class Test:
    def show():
        print("Hello")

t = Test()
t.show()


❌ Missing self

⸻

✅ Summary: ✔ Class = Blueprint ✔ Object = Instance ✔ init = Initializes data ✔ Method = Defines behavior ✔ Inheritance = Code reuse ✔ Encapsulation = Data protection ✔ Polymorphism = Multiple behavior 🚀

⸻

📢 Follow 👉 https://t.me/futurestack45 🔁 Share with friends to grow together 🚀

Day 18 – Exception Handling in Python
🔹 Definition: Exception handling is used to handle runtime errors so that the program does not crash and runs smoothly.

⸻

🔹 What is an Exception?
👉 An error that occurs during program execution
Example:
print(10 / 0)
❌ Output: ZeroDivisionError

⸻

🔹 try & except
👉 Used to handle errors

try:
    print(10 / 0)
except:
    print("Error occurred")


✅ Output: Error occurred

⸻

🔹 Handling Specific Exception

try:
    num = int("abc")
except ValueError:
    print("Invalid input")



⸻

🔹 Multiple Exceptions

try:
    a = int(input("Enter number: "))
    print(10 / a)
except ValueError:
    print("Enter valid number")
except ZeroDivisionError:
    print("Cannot divide by zero")



⸻

🔹 else Block
👉 Runs if no error occurs

try:
    print(10 / 2)
except:
    print("Error")
else:
    print("Success")



⸻

🔹 finally Block
👉 Always runs (error or not)

try:
    print(10 / 2)
except:
    print("Error")
finally:
    print("Execution completed")



⸻

🔹 Raising Exception
👉 Manually create error

age = -1

if age < 0:
    raise ValueError("Age cannot be negative")



⸻

🔹 Custom Exception

class MyError(Exception):
    pass

raise MyError("Custom error occurred")

⸻

❌ Common Mistakes
🚫 Using only except: (not specific) 🚫 Ignoring errors instead of handling 🚫 Not using finally for cleanup

⸻

✅ Summary
✔ try → test code ✔ except → handle error ✔ else → runs if no error ✔ finally → always runs ✔ raise → create error

Day 19 – Modules & Packages in Python
🔹 What is a Module?
👉 A module is a file that contains Python code (functions, variables, classes) which can be reused.
👉 Example:
If you create a file math_operations.py, it becomes a module.


⸻


🔹 Creating a Module
📄 math_operations.py
def add(a, b):
return a + b

def sub(a, b):
return a - b


⸻


🔹 Importing a Module
import math_operations

print(math_operations.add(5, 3))


⸻


🔹 Import Specific Functions
from math_operations import add

print(add(10, 5))


⸻


🔹 Import with Alias
import math_operations as mo

print(mo.sub(10, 3))


⸻


🔹 Built-in Modules
👉 Python already provides many modules
Examples:
math
random
datetime
os
import math
print(math.sqrt(16))


⸻


🔹 What is a Package?
👉 A package is a collection of multiple modules organized in folders.
📁 Example Structure:
my_package/
__init__.py
module1.py
module2.py


⸻


🔹 Import from Package
from my_package import module1

module1.function_name()


⸻


🔹
init.py File
👉 Marks a folder as a package
👉 Can be empty or contain initialization code


⸻


🔹 dir() Function
👉 Shows all functions/variables in a module
import math
print(dir(math))


⸻


❌ Common Mistakes
🚫 Wrong file path
🚫 Module name conflict (same as built-in module)
🚫 Forgetting init.py in package


⸻


✅ Summary
✔ Module → single Python file
✔ Package → collection of modules
✔ import → use module
✔ from → import specific items
✔ alias → rename module
✔ built-in modules → ready to use