Think about using a mobile phone.

You tap an app icon → the app opens.

You don’t see the thousands of lines of code running behind the scenes.

You only see what you need.

This idea — showing only essential details and hiding internal complexity — is called Abstraction.

It is one of the four major pillars of Object-Oriented Programming (OOP).

🧠 What is Abstraction?

Abstraction means:

Hiding internal implementation details and exposing only the necessary functionality.

In simple words:

You focus on what an object does, not how it does it.

🌍 Real-Life Example — Driving a Car

When you drive a car:

• You press the accelerator → car moves

• You press the brake → car stops

You don’t need to understand:

• Engine combustion

• Fuel injection system

• Mechanical components

The car hides the complexity.

That is abstraction.

🧩 Abstract Classes — The Blueprint with Rules

An abstract class is a special type of class that:

✔ Defines structure
✔ Contains abstract methods
✔ Cannot be instantiated (no objects allowed)

It acts like a rulebook for other classes.

It tells child classes:

“You must implement these methods.”

🔧 Abstract Methods — Methods Without Implementation

An abstract method is a method that:

• Is declared

• Has no body

• Must be implemented in child classes

Example idea:

Every animal must make a sound — but each animal’s sound is different.

So we define the rule, not the behavior.

🧑‍💻 How Python Implements Abstraction

Python provides abstraction using the abc module.

We import:

from abc import ABC, abstractmethod

ABC → Abstract Base Class
@abstractmethod → decorator to define abstract methods

🏗️ Creating an Abstract Class — Step by Step

Step 1: Import Required Module

from abc import ABC, abstractmethod

Step 2: Create Abstract Class

class Animal(ABC):

    @abstractmethod
    def sound(self):
        pass

Here:

• Animal → abstract class

• sound() → abstract method

• pass → no implementation

It simply says:

Every animal must have a sound method.

⚠️ Important Rule — Cannot Create Object

You cannot do this:

a = Animal()   # ❌ Error

Why?

Because the class is incomplete.

It only defines rules.

🐶 Creating Child Classes

Now we create real implementations.

class Dog(Animal):

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


class Cat(Animal):

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

Each child class provides its own implementation.

▶️ Using the Classes

d = Dog()
c = Cat()

d.sound()
c.sound()

Output:

Dog barks
Cat meows

Now everything works perfectly.

🚨 What Happens If We Don’t Implement?

If a child class does not implement the abstract method:

class Dog(Animal):
    pass

d = Dog()

Python will raise an error.

Because:

You broke the contract defined by the abstract class.

🎯 Why Do We Use Abstraction?

Abstraction helps us:

✔ Reduce complexity
✔ Enforce structure
✔ Improve maintainability
✔ Create scalable architecture
✔ Separate interface from implementation

It is heavily used in:

• Frameworks

• APIs

• Large applications

• System design

🌍 Real-Life Example — Remote Control

A remote control has buttons:

• power()

• volume_up()

• volume_down()

But TV, AC, and Projector implement them differently.

Remote → Abstract class
Devices → Child classes

The user presses buttons without knowing internal logic.

That is abstraction.

🔑 Abstract Class vs Normal Class

🧠 Abstract Method vs Normal Method

🚀 Memory Trick

Abstract = Incomplete Blueprint

Concrete Class = Complete Object

✨ When Should You Use Abstraction?

Use abstraction when:

✔ Multiple classes share a common structure
✔ Implementation differs across classes
✔ You want strict rules for developers
✔ You are designing large systems

🧪 Practice Questions

Beginner Level

1. Create an abstract class Vehicle with abstract method start()

2. Create child classes Car and Bike implementing start()

3. Print different messages for both

Intermediate Level

Create an abstract class Payment with:

• pay(amount)

• refund(amount)

Implement:

• CreditCardPayment

• UPIBasedPayment

Thinking Question

Why is abstraction useful in large software projects?

🏁 Final Thoughts

If:

Encapsulation protects data 🔒
Inheritance shares code 🔁
Polymorphism changes behavior 🎭

Then:

Abstraction hides complexity and enforces structure 🎯

It allows developers to build powerful systems without exposing unnecessary details.

🔜 What’s Next?

👉 Composition vs Inheritance — Which One Should You Use?

That’s where OOP design becomes even more interesting 🚀

✔ Classes and Objects — how we create real-world entities in code
✔ Encapsulation — how we protect and control data
✔ Inheritance — how child classes reuse parent features

Now comes one of the most powerful and flexible concepts in Object-Oriented Programming:

👉 Polymorphism

Don’t worry if the word sounds complicated. The idea behind it is actually very simple — and once you understand it, your code starts to feel much smarter and more natural.

🌍 What is Polymorphism?

Let’s break the word first:

Poly = Many
Morphism = Forms

👉 Polymorphism means “one thing that can take many forms.”

In programming, this means:

The same method name can behave differently depending on the object using it.

Instead of writing completely different functions, we reuse the same method name — but each object responds in its own way.

🧠 Real-Life Example

Think about the action “speak.”

• A Dog speaks → Bark 🐶

• A Cat speaks → Meow 🐱

• A Human speaks → Talk 🧑

Same action name — different behavior.

That’s exactly what polymorphism does in Python.

🧑‍💻 Basic Example — Method Overriding

Polymorphism most commonly appears through method overriding (which you saw a bit in inheritance).

class Animal:
    def speak(self):
        print("Animal makes a sound")

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

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

Now let’s create objects:

animals = [Dog(), Cat()]

for a in animals:
    a.speak()

Output:

Dog barks
Cat meows

👉 Notice something powerful:

We called the same method speak()
But each object behaved differently.

That’s polymorphism.

🔍 Why is Polymorphism Useful?

Imagine building a large system like a game or a school application.

Instead of writing:

dog_bark()
cat_meow()
human_talk()

You simply write:

object.speak()

Python automatically decides what to do.

Benefits:

✔ Cleaner code
✔ Less repetition
✔ Easier expansion
✔ Real-world behavior modeling

⚙️ Polymorphism Without Inheritance (Duck Typing)

Here’s something interesting about Python:

👉 Polymorphism doesn’t always need inheritance.

If different classes have the same method name, Python still treats them similarly.

class Car:
    def move(self):
        print("Car drives")

class Boat:
    def move(self):
        print("Boat sails")

class Plane:
    def move(self):
        print("Plane flies")

Now:

vehicles = [Car(), Boat(), Plane()]

for v in vehicles:
    v.move()

Output:

Car drives
Boat sails
Plane flies

Python doesn’t care about the class type —
it only cares whether the object has a move() method.

This concept is called Duck Typing:

“If it walks like a duck and quacks like a duck, it’s a duck.”

🔄 Method Overloading vs Method Overriding

Many beginners confuse these two, so let’s clarify clearly.

✔ Method Overriding

Happens in inheritance.

Child class replaces parent method behavior.

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

class Dog(Animal):
    def speak(self):
        print("Dog bark")

Same method name — new behavior.

⚠ Method Overloading in Python

Traditional overloading (same function name with different parameters like Java) is not directly supported in Python.

But Python achieves similar flexibility using:

• Default arguments

• *args

• **kwargs

Example:

class Math:
    def add(self, a, b, c=0):
        print(a + b + c)

m = Math()
m.add(2, 3)
m.add(2, 3, 4)

Same method — different usage.

🎯 Real-World Analogy

Think about a remote control:

• Press Play on TV → Video starts

• Press Play on Music Player → Song plays

• Press Play on Game Console → Game resumes

Same button.
Different behavior.

That’s polymorphism in everyday life.

🧪 Beginner Practice Questions

Try these after reading:

1️⃣ Animal Sounds Practice

Create:

• Parent class Animal

• Child classes Dog, Cat, Cow

Each should override a sound() method.

2️⃣ Shape Area Program

Create classes:

• Circle

• Rectangle

• Triangle

Each should have a method area() that prints its area.

Call all objects inside a list and loop through them.

3️⃣ Transport Example (Duck Typing)

Create classes:

• Bike

• Car

• Train

Each should have a move() method.

Call them using a loop without inheritance.

✨ Final Thoughts

Polymorphism makes your programs flexible and elegant.

Instead of writing different logic for every object, you define a common action — and let each class decide how to perform it.

If:

✔ Classes are blueprints
✔ Inheritance connects them

👉 Then polymorphism brings them to life by allowing dynamic behavior.

🔜 What’s Next?

Now that you understand:

• Classes & Objects

• Encapsulation

• Inheritance

• Polymorphism

You’re ready for the next pillar of OOP:

👉 Abstraction in Python — Hiding Complexity, Showing Only What Matters

Stay tuned for Article 6 🚀

For example:

• A Student and a Teacher both have a name and an email.

• A Car and a Bike are both vehicles.

• A Dog and a Cat are both animals.

Instead of rewriting the same code again and again, Python gives us a powerful concept called Inheritance.

🔍 What is Inheritance?

Inheritance allows one class to reuse the properties and methods of another class.

• The existing class is called the Parent (Base) class

• The new class is called the Child (Derived) class

👉 In simple words:
A child class “inherits” everything from its parent and can also add its own features.

🌍 Real-Life Example

Think of a family:

• Parents pass down traits like surname, habits, or values

• Children automatically get them

• But children also have their own unique qualities

Programming inheritance works the same way.

🧑‍💻 Basic Example in Python

class Animal:
    def speak(self):
        print("Animal makes a sound")

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

Here:

• Animal is the parent class

• Dog is the child class

• Dog automatically gets access to speak() from Animal

dog = Dog()
dog.speak()
dog.bark()

✅ No code duplication
✅ Clean and reusable design

🚀 Why Do We Use Inheritance?

Inheritance helps us:

✔ Avoid code repetition
✔ Improve readability
✔ Make programs easier to maintain
✔ Follow real-world relationships

🔁 Types of Inheritance in Python

1️⃣ Single Inheritance

One child, one parent.

class Parent:
    pass

class Child(Parent):
    pass

2️⃣ Multiple Inheritance

One child, multiple parents.

class Father:
    pass

class Mother:
    pass

class Child(Father, Mother):
    pass

⚠ Use carefully — can become confusing if overused.

3️⃣ Multilevel Inheritance

A chain of inheritance.

class Grandparent:
    pass

class Parent(Grandparent):
    pass

class Child(Parent):
    pass

4️⃣ Hierarchical Inheritance

Multiple children, one parent.

class Animal:
    pass

class Dog(Animal):
    pass

class Cat(Animal):
    pass

🔄 Method Overriding (Inheritance + Polymorphism)

This is where many learners get confused, so let’s be very clear.

👉 Overriding happens in inheritance.

A child class can change the behavior of a method inherited from the parent.

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

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

Same method name.
Different behavior.

This is called method overriding, and it is a form of polymorphism.

❌ Common Misconception

“Method overloading comes under inheritance.”

❌ Incorrect.

✔ Overloading → Polymorphism
✔ Overriding → Inheritance + Polymorphism

Python doesn’t support traditional method overloading like Java or C++.

🧠 When Should You Use Inheritance?

Use inheritance when:

• There is a clear “is-a” relationship

• Code can genuinely be reused

• You want to extend functionality, not just copy code

Example:

• Dog is an Animal ✅

• Car is an Vehicle ✅

✨ Final Thoughts

Inheritance is one of the core pillars of Object-Oriented Programming.
Once you understand it clearly, concepts like polymorphism and abstraction become much easier.

If classes are the blueprints, inheritance is what lets us build smarter, connected designs instead of isolated ones.

This article is part of my Python OOP Series. If you missed the earlier articles, start from Classes & Objects and Encapsulation to build a strong foundation.

🔜 What’s Next?

👉 Polymorphism in Python – Same Method, Different Behavior

That’s where your OOP journey gets really exciting 🚀

Encapsulation is one of those topics that sounds complex at first, but once you relate it to real life, it becomes very easy to understand.

🤔 What Is Encapsulation?

Encapsulation means binding data and the methods that operate on that data together, and restricting direct access to some parts of the data.

In simple words:

Encapsulation helps us protect data and control how it is accessed or modified.

We don’t allow anyone to change important data directly.
Instead, we provide safe ways to access or update it.

🏦 Real-Life Example: Bank Account

Think about your bank account.

Can you directly go to the bank’s database and change your balance?
No.

What can you do instead?

• Deposit money

• Withdraw money

• Check balance

Your balance is hidden, and you can access it only through proper actions.

This is exactly how encapsulation works.

🧪 Bank Account Example in Python

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance   # private variable

    def get_balance(self):
        return self.__balance

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def withdraw(self, amount):
        if amount <= self.__balance:
            self.__balance -= amount

Here:

• __balance is not accessible directly

• The user must use deposit() or withdraw()

• Rules are applied automatically

This makes the program safe and realistic.

📱 Real-Life Example: Mobile Phone

Think about your mobile phone.

You can:

• Increase or decrease volume

• Open apps

• Lock the phone

But you cannot:

• Directly control battery internals

• Modify hardware settings

The internal system is hidden, and you interact only through buttons and options.

This is encapsulation in real life.

🏫 Real-Life Example: Student Marks

In a school system:

• Students should not directly change their marks

• Only teachers can update marks

• Students can only view them

Python Example

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

    def get_marks(self):
        return self.__marks

    def update_marks(self, new_marks):
        if 0 <= new_marks <= 100:
            self.__marks = new_marks

Here:

• Marks are protected

• Invalid values are prevented

• Data remains consistent

🔐 Public, Protected, and Private Variables

Python controls access using naming conventions.

Public Variable

self.name

Accessible anywhere.

Protected Variable

self._email

Should not be accessed directly, but still possible.

Private Variable

self.__password

Strongly protected and used for sensitive data.

🔍 Difference Between Public, Protected, and Private Variables

Now that we’ve seen all three types, let’s clearly understand how they differ, especially in initialization and access.

🟢 Public Variables

Public variables are created normally and can be accessed from anywhere.

Example:

class User:
    def __init__(self, name):
        self.name = name   # public variable

Usage:

u = User("Alice")
print(u.name)   # Accessible

👉 Public variables are best used when the data is safe to expose, like names or IDs.

🟡 Protected Variables

Protected variables are defined using a single underscore _.

Example:

class User:
    def __init__(self, email):
        self._email = email   # protected variable

Usage:

u = User("abc@gmail.com")
print(u._email)   # Accessible, but not recommended

👉 Protected variables can be accessed, but by convention:

• They are meant to be used inside the class or its child classes

• Developers understand: “Use this carefully”

🔴 Private Variables

Private variables use double underscore __.

Example:

class User:
    def __init__(self, password):
        self.__password = password   # private variable

Usage:

u = User("secret123")
# print(u.__password)   ❌ Error

Private variables:

• Cannot be accessed directly

• Are internally renamed by Python (name mangling)

• Must be accessed using methods

Correct way:

class User:
    def __init__(self, password):
        self.__password = password

    def get_password(self):
        return self.__password

🧠 What’s the Real Difference?

⚠️ Important Note About Private Variables

To make a variable truly private in Python, you must use double underscore (__), not a single underscore.

❌ This is NOT private:

self._password

This is only protected, not private.
It can still be accessed directly.

✅ This IS private:

self.__password

This tells Python to:

• Apply name mangling

• Prevent direct access

• Treat the variable as internal to the class

🔍 Why Double Underscore Matters

Python uses the double underscore to change the variable name internally.

Example:

self.__password

Internally becomes:

_User__password

This is why:

user.__password   # ❌ Error

But:

user._User__password   # ⚠️ Technically possible, but not recommended

👉 This mechanism exists to discourage misuse, not to break your code.

🧠 Simple Rule to Remember

• _variable → Protected (use carefully)

• __variable → Private (use double underscore only)

• Never assume _ means private — it does not

💡 Key Takeaway

• Public → Anyone can access

• Protected → Access allowed, but use carefully

• Private → Access only through methods

This system helps us control data, prevent misuse, and write professional code.

⚠️ Why Encapsulation Is Important

Without encapsulation, this could happen:

account.balance = -5000

Which makes no sense.

Encapsulation prevents:

• Invalid data

• Accidental changes

• Logical errors

🧠 Important Point to Remember

Encapsulation does not mean hiding everything.

It means:

• Hide important data

• Allow controlled access using methods

💡 Why Encapsulation Matters in Real Projects

Encapsulation helps in:

• Writing clean code

• Protecting data

• Avoiding bugs

• Managing large applications

• Working in teams

That’s why encapsulation is used in real-world software systems.

📝 Practice Questions

Try answering these:

1. What is encapsulation in simple words?

2. Why should data not be accessed directly?

3. Create a User class with a private password.

4. What is the difference between public and private variables?

🏁 Conclusion

In this article, we learned:

• What encapsulation is

• Why data protection is important

• How Python implements encapsulation

• How real-life systems use encapsulation

Encapsulation helps us write secure, logical, and maintainable code.

🔜 What’s Next?

In the next article, we’ll learn about Inheritance in Python — how one class can reuse and extend another class.

👉 Article 4: Inheritance in Python — Reusing Code Efficiently

Keep learning 🚀

Think of this as the point where your code stops being just lines of instructions and starts acting like real-world entities.

🧩 What Are Classes and Objects?

Let’s start with a simple question:

How do you describe a “car” in real life?

You might say it has a color, brand, speed, and it can drive or stop.
In OOP, we represent such things as objects — something that has data (attributes) and actions (methods).

But before we can make an object, we need a class — a blueprint that tells Python what an object should look like.

🏗️ Class — The Blueprint

A class is like a recipe or a template.
It defines what data (attributes) and actions (methods) every object of that type will have.

For example:

class Car:
    def __init__(self, color, speed):
        self.color = color
        self.speed = speed

    def drive(self):
        print(f"Driving the {self.color} car at {self.speed} km/h")

    def brake(self):
        print(f"The {self.color} car has stopped.")

Here’s what’s happening:

• class Car: — defines a blueprint called Car.

• __init__() — a special method called the constructor, automatically runs when you create an object.

• self — refers to the current object being created.

• color and speed — attributes (data).

• drive() and brake() — methods (behaviors).

🚗 Object — The Real Instance

Now that we have a blueprint, we can create actual cars!

my_car = Car("Red", 120)
friend_car = Car("Blue", 100)

my_car.drive()
friend_car.brake()

Each object (my_car, friend_car) has its own copy of attributes.
They both come from the same blueprint (Car), but they can have different colors, speeds, and behaviors.

So, in simple words:

Class → Design,

Object → Real thing created using that design.

🎓 A Simpler Example — The Student Class

Let’s represent something more relatable: a student.

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

    def display_info(self):
        print(f"Student: {self.name}, Grade: {self.grade}")

s1 = Student("Alice", "A")
s2 = Student("Bob", "B")

s1.display_info()
s2.display_info()

Output:

Student: Alice, Grade: A  
Student: Bob, Grade: B

Here:

• Each student has their own data (name, grade).

• The method display_info() defines how that data is displayed.

• Both s1 and s2 are independent objects created from the same Student class.

⚙️ Understanding the self Keyword (Improved & Beginner-Friendly)

If there's one part of classes that confuses beginners the most, it’s this little word: self.
But don’t worry — once you understand it, classes instantly make sense.

👉 What is self?

self simply refers to the current object that is being created or used.

Think of it like this:

• When you make my_car = Car("Red", 120)
  → self becomes my_car inside the class

• When you make friend_car = Car("Blue", 100)
  → self becomes friend_car

So each object gets its own separate data, and self helps Python know which object we are talking about.

🧠 A Simple Analogy

Imagine a class as a form with blank fields:

Student Form

• Name: ___

• Grade: ___

Each student fills in their own details.
Inside the system:

• When Alice fills the form → self refers to Alice

• When Bob fills the form → self refers to Bob

So self.name is Alice’s name when Alice is the object,
and self.name is Bob’s name when Bob is the object.

🔍 Why is self needed?

Because inside a class, Python must know:

• Which object's name?

• Which object's grade?

• Which object's color?

• Which object's speed?

If we didn’t have self, every object would get confused with others.

🧪 Let's Look at a Clear Example

class Example:
    def show(self):
        print("Hello from", self)

When we do:

obj = Example()
obj.show()

Python actually converts it internally to:

Example.show(obj)

So self is automatically assigned the object obj.

📝 In Short

• self represents the object calling the method.

• It connects the class blueprint to the actual object in memory.

• Without self, your class wouldn’t know which object’s data to access.

🧠 Why Do We Need Classes and Objects?

Without classes, our code becomes messy as we try to manage data and behavior separately.
Using classes gives us several advantages:

1. Modularity – Each class focuses on a single purpose (like Car, Student, etc.).

2. Reusability – Once you write a class, you can reuse it in multiple programs.

3. Scalability – You can easily expand your code by adding more classes or features.

4. Real-World Mapping – Classes make your code feel natural, as they represent real-world entities.

💡 Analogy: Why This Matters

Imagine a school management system.
You’ll have:

• A Student class (name, roll number, grade)

• A Teacher class (subject, experience)

• A Course class (title, duration)

Each one has unique data and behaviors.
When you create an object, you’re basically saying, “Here’s a real example of that class.”
This modular design makes complex systems much easier to manage.

🏁 Conclusion

In this article, you learned:

• What classes and objects are.

• How to define a class using the class keyword.

• How to create and use objects.

• Why self is important.

• And how classes make your programs more structured and realistic.

Classes and objects are the foundation of OOP.
Now that you know how to create them, you’re ready to move on to the next exciting topic — Encapsulation — where we’ll learn how to protect and control access to data inside classes.

Stay tuned for Article 3: “Encapsulation in Python — Protecting Your Data” 🔒

📝 Practice Questions — Test Your Understanding

Here are some simple yet meaningful exercises to strengthen what you learned in this article.

1️⃣ Create a class called Book

Write a Python class that represents a book with:

• title

• author

• price

Add a method display_info() that prints the book's details.

Then create two book objects and display their information.

2️⃣ Build a Phone class

Your class should have:

• brand

• model

• battery_percentage

Add two methods:

• charge() → prints “Charging…”

• status() → prints battery percentage

Create an object and call these methods.

3️⃣ Create a Pet class

Attributes:

• name

• animal_type (ex: dog, cat)

Methods:

• sound() → print a generic sound:

  • “Bark” for dog

  • “Meow” for cat

  • Something else for others

Hint: Use if–elif inside the method.

4️⃣ Trace the value of self

Given:

class Demo:
    def show(self):
        print(self)

d1 = Demo()
d2 = Demo()

d1.show()
d2.show()

❓ What do you think the output represents?
(Explain how Python internally treats self.)

5️⃣ Write a class Movie

Attributes:

• name

• year

• rating

Method:

• is_hit() → prints

  • “Hit movie!” if rating > 8

  • “Average movie” if rating between 5 and 8

  • “Flop movie” otherwise

Create three objects and test your method.

6️⃣ Predict the Output

class Test:
    def __init__(self, x):
        self.x = x

    def update(self, value):
        self.x = value

t1 = Test(5)
t2 = Test(10)

t1.update(20)
print(t1.x)
print(t2.x)

❓ What will be printed?
(Explain why the two objects behave independently.)

7️⃣ Create your own real-world class

Pick anything from your daily life:

• Laptop

• Bag

• Coffee Machine

• Bicycle

• Teacher

• Game Character

Define at least:

• 2 attributes

• 2 methods

and then create two objects of that class.

This exercise helps you think in an object-oriented way.

Imagine you’re creating a game.
You have players, enemies, weapons, and magical potions.
Each of these has attributes (like health, power, name) and behaviors (like attack, heal, move).

Now, how do we manage all this in code?

If we just used variables and functions everywhere, our code would become messy — a jungle of logic and repetition.

That’s when the idea of Object-Oriented Programming (OOP) was born — to make code organized, reusable, and real-world-like.

💡 What is Object-Oriented Programming (OOP)?

Object-Oriented Programming is a programming approach where we model the real world using classes and objects.

Instead of writing loose code, we group related data and actions together.

You can think of it as:

Classes are blueprints.
Objects are actual things built from those blueprints.

🏠 Analogy: Class and Object

Think of a Class like an architect’s blueprint for a house.
It defines the design — how the house will look, how many doors, windows, etc.

An Object is the actual house built using that blueprint.

Similarly, in Python:

class House:
    pass

my_house = House()

Here:

• House is a class

• my_house is an object (or instance) of that class

🧱 Why Do We Need OOP?

Before OOP, code was mostly procedural — we just wrote functions and called them in sequence.

But as programs got bigger, we needed:

• Reusability ♻️

• Organization 🗂️

• Readability 👀

• Real-world representation 🧍‍♀️💻

OOP solved all of these by letting us group data (variables) and behavior (functions) together in one unit — the object.

🧩 OOP Concepts at a Glance

There are 4 pillars (core concepts) that form the foundation of OOP:

We’ll explore each one deeply in the upcoming articles — but for now, let’s learn the basics.

🧱 Creating a Class in Python

A class defines how an object will look and behave.

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

    def introduce(self):
        print(f"Hi, I'm {self.name} and I'm {self.age} years old.")

Here:

• __init()__ is a constructor — it automatically runs when you create a new object.

• self refers to the current object.

• introduce() is a method (a function that belongs to a class).

🧍‍♀️ Creating an Object

Now, let’s create objects (instances) of the class:

student1 = Student("Prajitha", 20)
student2 = Student("John", 21)

student1.introduce()
student2.introduce()

Output:

Hi, I'm Prajitha and I'm 20 years old.
Hi, I'm John and I'm 21 years old.

🎯 Each object has its own copy of the data (name, age) but shares the same method structure.

⚙️ Understanding __init()__ and self

When you write:

student1 = Student("Prajitha", 20)

Python internally calls:

Student.__init__(student1, "Prajitha", 20)

That’s why the first parameter is always self — it refers to the current instance being created.

Think of self like saying “this particular object.”

💬 Adding Methods (Behaviors)

You can add multiple methods to define what an object can do:

class Car:
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color

    def start_engine(self):
        print(f"{self.brand} is starting...")

    def show_details(self):
        print(f"Car Brand: {self.brand}, Color: {self.color}")

Now create an object:

car1 = Car("Tesla", "Red")
car1.start_engine()
car1.show_details()

Output:

Tesla is starting...
Car Brand: Tesla, Color: Red

🧰 Modifying Attributes

Objects can have their data updated later:

car1.color = "Blue"
car1.show_details()

Output:

Car Brand: Tesla, Color: Blue

🪄 Class vs Instance Variables

Let’s go a bit deeper 🔍

Instance Variable

Belongs to a specific object.

self.name = "Prajitha"

Class Variable

Shared by all objects of that class.

class Student:
    college = "Aditya Degree College"  # class variable

    def __init__(self, name):
        self.name = name  # instance variable

s1 = Student("Prajitha")
s2 = Student("John")

print(s1.college)  # Aditya Degree College
print(s2.college)  # Aditya Degree College

🧠 Recap — What You Learned So Far

You’ve now learned:
✅ What OOP is and why we use it
✅ What classes and objects are
✅ How constructors (__init__) work
✅ The purpose of self
✅ How to define methods and variables inside classes

You’ve officially taken your first step into the OOP universe 🌌

🚀 Next in the Series

In Article 2, we’ll explore more about
👉 Classes, Objects and constructors.

✨ Final Thought

“Procedural code makes you think in steps,
OOP makes you think in systems — just like the real world.”

The world around you is made of objects — from your phone to your laptop to your car.
Now you’ve learned how to represent them in code. 🌍💻

Even after we develop a project and test it thoroughly, there might be cases we miss. If such errors occur when the program is running, we don’t want our clients or users to see a scary error message. Instead, we want to handle it gracefully and display a message of our choice.

This is where Exception Handling comes into play.

👉 It is a safe way to deal with errors without crashing the program.

2. WHAT IS AN EXCEPTION?

An exception is an error that happens during the execution of a program. Unlike syntax errors (which stop the program before running), exceptions occur while the program is running.

Some common examples are:

ZeroDivisionError → when we try to divide a number by zero.

FileNotFoundError → when the program tries to open a file that doesn’t exist.

TypeError → when an operation is applied to an object of an inappropriate type.

3. BASIC TRY AND EXCEPT

The try-except block is the foundation of exception handling.

Syntax:

try:
    # risky code

except SomeError:
    # handling code

Example: Dividing by zero

try:
    a = int(input("Enter A value: "))
    b = int(input("Enter B value: "))
    result = a / b
    print(result)

except ZeroDivisionError:
    print("We can't divide a number by zero")

Output:

Enter A value: 5
Enter B value: 0
We can't divide a number by zero

4. MULTIPLE EXCEPT BLOCKS

We can handle different types of errors separately.

try:
    a = int(input("Enter A value: "))
    b = int(input("Enter B value: "))
    result = a / b
    print(result)

except ZeroDivisionError:
    print("Error: Division by zero is not allowed.")

except ValueError:
    print("Error: Please enter only numbers.")

5. USING ELSE BLOCK

The else block runs only if no error occurs in the try block.

try:
    num = int(input("Enter a number: "))
    print("Square:", num ** 2)

except ValueError:
    print("Please enter a valid number.")

else:
    print("No errors occurred!")

6. FINALLY BLOCK

The finally block runs no matter what — whether there is an exception or not. It is useful for cleanup tasks like closing a file or database connection.

try:
    file = open("sample.txt", "r")
    content = file.read()

except FileNotFoundError:
    print("File not found!")

finally:
    print("Execution completed.")

7. RAISING EXCEPTIONS

We can raise our own exceptions using the raise keyword.

age = int(input("Enter your age: "))
if age < 0:
    raise ValueError("Age cannot be negative")

else:
    print("Valid age entered")

8. CUSTOM EXCEPTIONS

Sometimes the built-in exceptions like ValueError, TypeError, or ZeroDivisionError may not be enough for our program’s needs. In those cases, we can define our own exceptions.

A custom exception is nothing but a user-defined error type. We create it by writing a class that inherits from the built-in Exception class. This makes our code more readable and helps us provide specific error messages for special situations.

class InvalidAgeError(Exception):
    pass

age = int(input("Enter your age: "))
if age < 18:
    raise InvalidAgeError("You must be 18 or older to register")

9. WHY IS IT IMPORTANT?

✔ Prevents sudden crashes

✔ Makes debugging easier

✔ Provides user-friendly error messages

✔ Essential in file handling, user input validation, and working with APIs

✔ Helps in building reliable applications

10. PRACTICE QUESTIONS

Handle division by zero error with a custom message.

Write a program to read a file and handle the case if the file doesn’t exist.

Create a custom exception for invalid password length.

11. CONCLUSION

Exception handling makes Python programs strong, reliable, and crash-proof. It ensures that even if errors occur, our application handles them gracefully.

File handling is a very crucial and important concept when we want to store user data. For example, if we develop a website and want to store the information of each and every user and their details, then we can use this concept of file handling.

We can create files in different formats such as text files, CSV files, Excel files, or JSON files. File handling helps us to store the user data permanently. This means that even if the user exits our program, the data will not be lost unless we explicitly delete the file. Once we write code for file handling, the program can automatically store and manage information.

We have different types of file handling modes such as reading, writing/overwriting, appending, and even deleting a file.

2. OPENING FILES

To open a file, we use the open() function.

Syntax

file = open("file_name", file_mode)

Here, file mode refers to the action we want to perform. The common modes are:

"r" → read (default mode)

"w" → write (overwrites existing content)

"a" → append (adds content at the end of file)

"x" → create a new file (gives error if file already exists)

3. FILE PROPERTIES

After opening a file, we can check its properties using different methods:

f.name → returns the name of the file

f.mode → returns the current file mode

f.closed → returns True if the file is closed, else False

f.close() → closes the file

4. READING FILES

When reading a file, there are three main methods:

read() → Reads the entire file at once.

readline() → Reads one line at a time.

readlines() → Reads all lines into a list.

Example file: practice.txt

Hello
This is a text file
It is an example for read() function
It reads entire file

Example 1 – read()

f = open("practice.txt", "r")
content = f.read()
print(content)
f.close()

Output:

Hello
This is a text file
It is an example for read() function
It reads entire file

Example 2 – readline()

f = open("practice.txt", "r")
print(f.readline())
f.close()

Output:

Hello

Example 3 – multiple readline()

f = open("practice.txt", "r")
print(f.readline())
print(f.readline())
f.close()

Output:

Hello
This is a text file

5. WRITING FILES

To write into a file, we use:

write() → Writes a single string into the file.

writelines() → Writes multiple lines into the file.

⚠️ Note: If we open a file in "w" mode, it will erase all existing content and start fresh.

Example:

f = open("practice.txt", "w")
f.write("This text will overwrite the file content.")
f.close()

6. APPENDING TO FILES

Appending allows us to add new content to the end of the file without deleting the existing data.

Example:

f = open("practice.txt", "a")
f.write("\nThis line is added at the end.")
f.close()

7. CLOSING FILES

It’s important to close a file after operations to free up system resources.

f.close()

If we forget to close, Python may still keep it open in memory, which can cause errors in bigger applications.

8. USING with STATEMENT

Instead of manually closing a file, we can use a with statement which automatically closes it once the block ends.

Example:

with open("practice.txt", "r") as f:
content = f.read()
print(content)
# file is automatically closed here

This is considered the best practice.

9. WORKING WITH DIFFERENT FILE TYPES

Python makes it easy to work with different file types:

Text Files → read/write using normal methods.

CSV Files → use the csv module.

import csv
with open("data.csv", "r") as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

JSON Files → use the json module.

import json
data = {"name": "Alice", "age": 22}
with open("data.json", "w") as f:
    json.dump(data, f)

10. PRACTICE QUESTIONS

Try solving these on your own 👇

1. Read a text file and count how many words are in it.

2. Write student names and marks into a file.

3. Append daily logs with date and time.

4. Convert a Python dictionary into JSON and save it.

5. Read a CSV file and print each row.

11. CONCLUSION

File handling allows Python programs to interact with the outside world.

It is useful for:

—> Storing user data permanently

—> Automating tasks

—> Handling logs

—> Building real-world applications

By learning how to open, read, write, and manage files, we make our programs more powerful and practical.

When we write small programs, everything fits into one file. But as our project grows, writing all the code in a single place becomes confusing and hard to manage.

That’s where modules and packages in Python come to the rescue.

Module → A Python file (.py) that contains functions, variables, or classes.

Package → A collection of modules grouped together inside a folder with an __init__.py file.

📘 Think of it like this:

A module is like a single chapter in a book.

A package is like the whole book with multiple chapters.

Both are meant to keep our code organized, reusable, and easier to share.

2. WHY DO WE NEED MODULES?

Imagine you are building a calculator. First, you write an add function. Later, you need subtraction, multiplication, division, etc. If you put everything inside one file, it becomes messy.

Instead, you can create a module called calculator.py that contains all the math-related functions. Later, whenever you want to use it, just import it into another program.

Benefits of modules & packages:

✅ Avoids code duplication.

✅ Makes projects structured and readable.

✅ Allows teamwork (different people can work on different modules).

✅ Easy to debug and maintain.

✅ Shareable across projects.

3. IMPORTING BUILT-IN MODULES

Python already comes with many built-in modules that we can use directly.

Example using the math module:

import math
print(math.sqrt(16)) # Square root
print(math.factorial(5)) # Factorial of 5
print(math.pi) # Value of Pi

Example using the random module:

import random
print(random.randint(1, 10)) # Random number between 1 and 10
print(random.choice(["apple", "banana", "cherry"])) # Randomly picks one

Example using the datetime module:

import datetime
today = datetime.date.today()
print("Today's date:", today)

💡 These built-in modules save a lot of time since we don’t need to write everything from scratch.

4. DIFFERENT WAYS TO IMPORT

There are multiple ways to bring a module into our code:

import math
print(math.sqrt(25)) # Using full module name

from math import sqrt
print(sqrt(25)) # Directly using the function

import math as m
print(m.sqrt(36)) # Using alias

👉 Choosing between these depends on readability. If we use only 1–2 functions, from ... import ... makes sense. If we use many, import module is better.

5. CREATING YOUR OWN MODULE

We can create our own custom module too.

Example: Create a file mymodule.py with:

# mymodule.py

def greet(name):
return f"Hello, {name}!"
def add(a, b):
return a + b

Now in another Python file:

import mymodule
print(mymodule.greet("Prajitha"))
print(mymodule.add(5, 3))

💡 This makes your functions reusable across multiple projects.

6. PACKAGES

Modules are good for small programs. But what if your project has dozens of modules?

That’s where packages help.

A package is simply a folder with multiple modules and a file called __init__.py.

Example project structure:

mypackage/

__init__.py

calculator.py

greetings.py

Inside calculator.py:

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

Inside greetings.py:

def say_hello():
    return "Hello from greetings!"

Now, you can use them:

from mypackage import calculator, greetings
    print(calculator.add(10, 20))
    print(greetings.say_hello())

📦 Packages are very useful in large applications where code needs to be modular.

7. INSTALLING EXTERNAL PACKAGES

Apart from built-in modules and our own modules, Python has a huge library of third-party packages created by developers worldwide. These packages are stored in PyPI (Python Package Index). We install them using pip.

Example:

pip install requests

Usage in code:

import requests
response = requests.get("https://api.github.com")
print(response.status_code) # Output: 200

💡 Famous Python packages:

numpy → numerical operations

pandas → data analysis

matplotlib → data visualization

flask → web applications

requests → APIs and web requests

8. PRACTICE QUESTIONS

Try these on your own 👇

1. Import the datetime module and print today’s date.

2. Create your own module with a function that checks whether a number is prime.

3. Write a program using the random module to simulate rolling a dice.

4. Create a package shapes with circle.py and square.py that calculate areas.

5. Install the emoji package (pip install emoji) and print a smiling emoji.

9. CONCLUSION

🔑 Key takeaways:

Modules = Single file with reusable code.

Packages = Collection of modules inside a folder.

Built-in modules like math, random, datetime make life easier.

External packages from PyPI make Python powerful and versatile.

👉 Mastering modules and packages is essential if you want to move from small scripts to real-world scalable projects.

Functions are used when we want to group a block of code and reuse it multiple times. Instead of writing the same code again and again, we can just create a function and call it whenever needed.

👉 Example from real life: If you use a calculator, you don’t need to build “add” or “subtract” again and again. The calculator already has those functions. Similarly, in Python, we can define functions once and use them whenever we need.

2. CREATING A FUNCTION

Syntax –

def function_name():
    # code block

Example:

def greet():
    print("Hello, welcome to Python!")

greet()

Output –

Hello, welcome to Python!

So here:

• def → keyword used to define a function.

• greet() → function name.

• () → parentheses where arguments can be passed (if required).

• Function is called by using its name followed by ().

3. FUNCTION ARGUMENTS

Arguments are values that we pass to a function so that it can work with them.

Let’s see the different types:

(a) Positional Arguments

These are the most common. The order matters.

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

add(5, 3)

Output –

8

Here a=5 and b=3. The function adds them.

(b) Default Arguments

We can give a default value. If we don’t pass anything, the default is used.

def greet(name="Guest"):
    print("Hello,", name)

greet()
greet("Prajitha")

Output –

Hello, Guest
Hello, Prajitha

(c) Keyword Arguments

We can pass arguments in any order by using keywords.

def student(name, age):
    print("Name:", name, "Age:", age)

student(age=20, name="John")

Output –

Name: John Age: 20

(d) Arbitrary Arguments

Sometimes we don’t know how many arguments will be passed.

1. *args → for multiple positional arguments

def fruits(*args):
    for fruit in args:
        print(fruit)

fruits("Apple", "Mango", "Banana")

Output –

Apple
Mango
Banana

Here, args behaves like a tuple.

2. **kwargs → for multiple keyword arguments

def student_details(**kwargs):
    for key, value in kwargs.items():
        print(key, ":", value)

student_details(name="Ananya", age=22, course="AI")

Output –

name : Ananya
age : 22
course : AI

Here, kwargs behaves like a dictionary.

4. RETURN STATEMENT

Functions can also return values back.

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

result = multiply(4, 5)
print(result)

Outpu –

20

👉 Difference:

• print() → only displays.

• return → sends the result back, which we can use later.

5. VARIABLE SCOPE

• Local Variable → created inside a function (used only inside).

• Global Variable → created outside any function (used everywhere).

x = 10  # global

def show():
    y = 5  # local
    print("Inside:", x + y)

show()
print("Outside:", x)

6. NESTED FUNCTIONS

A function inside another function.

def outer():
    def inner():
        print("This is inner function")
    inner()

outer()

7. RECURSION

When a function calls itself.

Example – Factorial

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n-1)

print(factorial(5))

Output –

120

8. LAMBDA FUNCTIONS

Anonymous (nameless) functions. Usually one-liners.

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

Output –

36

Also useful with map() and filter().

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

Output –

[1, 4, 9, 16]

9. PRACTICE QUESTIONS

Try solving these 👇

1. Write a function to calculate the area of a circle (take radius as input).

2. Create a function that returns the maximum number in a list.

3. Write a recursive function for Fibonacci numbers.

4. Write a function that checks if a number is prime.

5. Write a function that checks if a string is a palindrome.

6. Create a lambda function to find the cube of a number.

7. Write a function that counts vowels in a string.

8. Use *args to find the sum of any number of numbers.

10. CONCLUSION

Functions are used to write clean, reusable and modular code.

• Positional, default, keyword, args and *kwargs make functions flexible.

• Return statement is used to send results back.

• Scope decides where variables can be used.

• Advanced concepts like recursion and lambda make functions even more powerful.

👉 Mastering functions is very important because every Python program is built on top of them.

11. BONUS PRACTICE

🔹 Calculator Function → Create a function that performs add, subtract, multiply, divide.
🔹 ATM Function → A function with deposit, withdraw, and balance check.
🔹 Student Grade Function → Function to calculate grade from marks.

Loops which are also called as iterative statements are useful when we want to repeat some of the tasks until a condition is satisfied. For example, if there are 10 students then we want to check the grade of every student, then we can use the concept of loops. The number of times the loop has to be executed are called as iterations.

2. TYPES OF LOOPS

There are three different types of loops that are available
1. for loop
2. while loop
3. nested loop

3. FOR LOOP

Syntax -

for variable_name in range (how many times to iterate):
    # code to be executed for each iteration

EXAMPLE - 1 :

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

'''
  output - 0
           1
           2
           3
           4
           5
'''

# The reason that the loop stopped printing at 5 is that when we mention a number n then 
# range will iterate from 0 to n-1

EXAMPLE -2 :

i = 1
for num in range (i,10,3):
    print(num)

'''
Output - 1
         4
         7
'''

# In the loop we have mentioned as i, 10, 3 so for each iteration it will add the i value to 3 and
# checks the condition.

EXAMPLE - 3 : We can use loops to iterate over the elements in a list, tuple, dictionary or even set.

colours = ["Blue", "Green", "Red", "Yellow"]
for element in colours:
    print(element)

'''
Output - Blue
         Green
         Red
         Yellow
'''

4. WHILE LOOP

It is very similar to for loop but the main difference is based on if we know how many times the loop has to iterate. In for loop we have to mention how many times the loop has to iterate but not many of the times we will know answer to this question so in that case we can use while loop.

A real life example for while loop is that if we open a website or an application we may use it just for a few seconds or for minutes or for hours so we can use while loop stating that the app has to work until the user is using the app.

Syntax -

while condition:
    # statements to be executed

EXAMPLE - 1

num = 0
while num <= 5:
    print(num)
    num += 1 # num = num + 1

'''
Output - 0
         1
         2
         3
         4
         5
'''

5. LOOP CONTROL STATEMENTS

These loop control statements are used while the loop is executing and will control a loop if a condition is satisfied. There are three types of loop control statements

1. break

2. continue

3. pass

1. BREAK - It will stop the loop if a condition is satisfied.

Example - In an e-commerce website we may want to cancel the whole order if an UPI payment is failed

i = 1
for num in range (i,10):
    if num == 5:
        break
    print(num)

'''
Output - 1
         2
         3
         4
'''

2. CONTINUE - continue is used when we want to skip an iteration if a condition is satisfied.

Example - Just like in the above example of e-commerce the the user selects COD then we may want to skip the UPI or any other online payment option.

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

'''
Output - 1
         2
         4
         5
'''

3. PASS - Pass is used for checking a condition and it does not do anything and acts like a placeholder.

Example -

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

'''
Output - 1
         2
         3
         4
         5
'''

6. NESTED LOOPS

A nested loop is a loop that is present inside a loop.

Example -

for i in range (1,6):
    for j in range (1,6):
        print("*",end="") 
# By default, print() moves the cursor to a new line after each call. 
# Using end="" prevents that, so the stars are printed on the same line.

'''Output -
*****
*****
*****
*****
*****
'''

7. DIFFERENCE BETWEEN PASS AND CONTINUE

• continue →Skips the current iteration and moves to the next one.

• pass → Does nothing, just acts as a placeholder, and execution continues normally.

8. PRACTICE QUESTIONS

Try solving these on your own 👇

1. Write a for loop to print the first 10 even numbers.

2. Print all characters of the string "Python" using a for loop.

3. Use a while loop to print numbers from 10 down to 1.

4. Print the multiplication table of 7 using a loop.

5. Write a loop that calculates the sum of numbers from 1 to 100.

6. Print only odd numbers from 1 to 20 using a loop.

7. Write a nested loop to print a 3×3 matrix of numbers.

8. Use continue to skip printing the number 5 from a range of 1–10.

9. Write a program that uses pass inside a loop.

10. Create a while loop that keeps asking the user to input a number until they type "stop".

9. CONCLUSION

• Loops help in executing repetitive tasks efficiently.

• for loop → Best when the number of iterations is known.

• while loop → Best when the number of iterations is unknown.

• Loop control statements (break, continue, pass) give more flexibility while controlling iterations.

• Mastering loops is essential, as they are the backbone of problem-solving in Python.

QUICK REVISION

10. BONUS PRACTICE

1. Number Guessing Game

   • Generate a random number.

   • Keep asking the user to guess until they get it right.

   • Provide hints like "Too High" / "Too Low".

2. To-Do List Program

   • Keep asking for tasks until the user types "done".

   • Store and print the final to-do list.

Conditional statements are very helpful in any programming language. They allow us to execute certain parts of code only when specific conditions are met.

Think of them as decision-making tools in programming:

• If it rains, take an umbrella.

• If it’s summer, wear light-colored clothes to stay cool.

In Python, the main conditional statements are:

• if

• if-else

• if-elif-else

• Nested if

🔹 Precautions

While writing conditional statements in Python, remember:

• Indentation (spaces) is mandatory.

• Don’t forget the colon : at the end of each condition.

🔹 Taking Input from User

In real-world programs, we cannot predict what value a user will enter. So, we take input using the input() function.

number = int(input("Enter a value: "))
print(number)

# Example Input: 20
# Output: 20

text = input("Enter some text: ")
print(text)

# Example Input: Hello
# Output: Hello

🔹 1. Simple if Statement

Used when we want to check a single condition.

Syntax:

if (condition):
    # statements to execute if condition is True

Example:

num1 = 10
if num1 > 0:
    print("Positive")
# Output: Positive

🔹 2. if-else Statement

Used when we want one block to run if the condition is True, and another if it’s False.

Syntax:

if (condition):
    # statements if condition is True
else:
    # statements if condition is False

Example:

age = int(input("Enter your age to check voting eligibility: "))

if age >= 18:
    print("You are eligible to vote.")
else:
    print("You are not eligible to vote.")

🔹 3. if-elif-else Statement

Used when we need to check multiple conditions.

Syntax:

if (condition1):
    # statements
elif (condition2):
    # statements
else:
    # statements if all conditions fail

Examples:

👉 Checking positive, negative, or zero:

num = int(input("Enter a value: "))

if num > 0:
    print("Positive")
elif num < 0:
    print("Negative")
else:
    print("Zero")

👉 Grading System:

marks = int(input("Enter your marks: "))

if marks >= 85:
    print("A grade")
elif marks >= 70:
    print("B grade")
elif marks >= 50:
    print("C grade")
elif marks >= 35:
    print("D grade")
else:
    print("F grade")

🔹 4. Nested if Statement

Used when one condition depends on another condition.

Example:

num = int(input("Enter a value: "))

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

🔹 5. Ternary Operator (Short-Hand if)

A compact way of writing if-else in a single line.

Example:

num = 13
result = "Even" if num % 2 == 0 else "Odd"
print(result)
# Output: Odd

🔹 Mini Projects / Practice

1. ATM Withdrawal Check

   • Input: account balance and withdrawal amount.

   • Output: whether withdrawal is possible.

2. Login System

   • Input: username & password.

   • Output: successful login or invalid credentials.

✅ Conclusion:
Conditional statements help us control the flow of execution in Python. They are the foundation for problem-solving and decision-making in programs.

Next up: Loops in Python (for, while) 🚀

In this article, we’ll explore what sets are, how to use them, and why they are so useful in Python programming.

🔹 What is a Set in Python?

A set is an unordered collection of unique elements.

• Unordered → The items do not have an index or a fixed position like lists or tuples.

• Unique → Duplicate elements are automatically removed.

Think of a set as a mathematical set — it either contains an element or it doesn’t.

Example:

# Creating a set
my_set = {1, 2, 3, 4, 4, 2}

print(my_set)  
# Output: {1, 2, 3, 4}  → duplicates are removed automatically

🔹 Creating Sets

You can create a set in two ways:

Way - 1:

# Using curly braces
numbers = {1, 2, 3, 4, 1}
print(numbers)
#output - {1, 2, 3, 4}

Way - 2:

# Using set() constructor
letters = set(["a", "b", "c", "a"])
print(letters)  
# Output: {'a', 'b', 'c'}

👉 Notice how duplicates vanish!

⚠️ Important: While initiating an empty set it must be created using set() and not {}, because {} creates an empty dictionary. You can see it practically below:

empty_set = set()
empty_dict = {}
print(type(empty_set))  # <class 'set'>
print(type(empty_dict)) # <class 'dict'>

🔹 Accessing Set Elements

Since sets are unordered, you can’t access elements using an index. But you can:

• Loop through a set

  ```python fruits = {"apple", "banana", "cherry"}

  Looping

  for f in fruits: print(f)

'''output - banana apple cherry '''

    Since sets are unordered, we will get different outputs every time we run the code.

* **Check membership** using `in`


```python
# Membership check
print("apple" in fruits)   # output - True
print("grape" in fruits)   # output - False

🔹 Adding and Removing Elements

Sets are mutable, so we can add or remove elements.

# Add an element
fruits.add("mango")
print(fruits)

# Add multiple elements
fruits.update(["kiwi", "orange"])
print(fruits)

# Remove elements
# If we try to remove an element that is not present the remove function will give an error
# and the discard method will not produce any error.
fruits.remove("apple")   # Error if not found
fruits.discard("grape")  # No error if not found
print(fruits)

# Pop removes a random element
removed = fruits.pop()
print("Removed:", removed)

🔹 Set Operations (Like in Math!)

One of the coolest things about sets is that they support mathematical set operations:

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

print(A | B)  # Union(Adds the elements of set A and B) → {1, 2, 3, 4, 5, 6}
print(A & B)  # Intersection(Common elements in both sets) → {3, 4}
print(A - B)  # Difference(Elements present in set A that are not present in set B) → {1, 2}
print(B - A)  # Difference(Elements present in set B that are not present in set A) → {3, 4}
print(A ^ B)  # Symmetric Difference(Unique elements in both the sets) → {1, 2, 5, 6}

🔹 Why Use Sets?

Sets are super useful when:
✅ You want to remove duplicates from a collection
✅ You need fast membership testing (in is much faster in sets than in lists)
✅ You want to perform mathematical operations like union, intersection, and difference

Example: Removing duplicates from a list

numbers = [1, 2, 2, 3, 4, 4, 5]
unique_numbers = list(set(numbers))
print(unique_numbers)  # [1, 2, 3, 4, 5]

🔹 Frozen Sets (Immutable Sets)

Sometimes you need an immutable set (cannot be changed). That’s where frozenset() comes in. Once a frozenset is created we can not manipulate any elements.

fs = frozenset([1, 2, 3, 4])
print(fs)

# fs.add(5)  ❌ Error → frozenset object has no attribute 'add'

🔹 Conclusion

Python Sets are a powerful and flexible data structure. They:

• Ensure uniqueness of elements

• Allow fast membership checks

• Support mathematical set operations

• Have a special immutable version called frozenset

Next time you need to handle unique and unordered data, reach for sets! 🚀

📝 PRACTICE

Now it’s time to test what you’ve learned about sets! Try solving the following tasks:

1. Create a set of your 5 favorite fruits.

   • Add a new fruit to the set.

   • Remove one fruit using discard().

   • Try removing a fruit that does not exist and observe what happens.

2. Create two sets:

   • A = {1, 2, 3, 4, 5}

   • B = {4, 5, 6, 7, 8}
     Perform the following:

   • Union

   • Intersection

   • Difference (A - B and B - A)

   • Symmetric Difference

3. Remove duplicates from this list using a set:

    nums = [10, 20, 10, 30, 40, 20, 50, 30]
   

4. Create a frozen set using numbers from 1–5.

   • Try to add a number to it and see what happens.

5. You have two lists of students:

    math_students = ["Alice", "Bob", "Charlie", "David"]
    science_students = ["Charlie", "David", "Eva", "Frank"]
   

   • Find students who are enrolled in both subjects.

   • Find students who are enrolled in only Math but not Science.

   • Find students who are in at least one subject.

INTRODUCTION

In this article, we are going to learn about the concept of tuples in Python. As we discussed in the earlier article about lists, we can think of tuples as lists — but unlike lists, tuples are immutable (not changeable).

WHAT IS A TUPLE?

Tuples are very useful in real-world applications. You might wonder: Why are tuples useful if we cannot change them?

Well, sometimes we want data that must remain fixed. For example, think about your Google account. You use this account to log in or sign up for different platforms. If that account were to be modified, you could lose access to those platforms.

That’s where tuples come in — they allow us to store unchangeable, reliable data.

To create a tuple, we assign values inside parentheses () to a variable. Similar to lists, tuples can hold multiple data types.

CREATING TUPLES

We can create a tuple with:

• no elements,

• a single element, or

• multiple elements.

Empty Tuple

tuple1 = ()
print(tuple1)
# Output: ()

Single Element

tuple2 = (5,)
print(tuple2)
# Output: (5,)

⚠️ Note: Don’t forget the comma after the single element. If you write (5), Python treats it as just the number 5, not a tuple.

Multiple Elements

tuple3 = (1, 2, 3, 4, 5)
print(tuple3)
# Output: (1, 2, 3, 4, 5)

ACCESSING ELEMENTS

Just like lists, tuples support indexing. The first element has index 0.

a = ("a", "b", 11, "d", 0, "f")
print(a)        # ('a', 'b', 11, 'd', 0, 'f')
print(a[0])     # a
print(a[-1])    # f
print(a[1:3])   # ('b', 11)

IMMUTABLE

Unlike lists, tuples are immutable — we cannot modify them once created.

a = ("a", "b", 11, "d", 0, "f")
a[0] = 1   # ❌ Error

TUPLE OPERATIONS

1. Concatenation

Combine two or more tuples:

tuple1 = ("a", "e")
tuple2 = ("i", "o", "u")
vowels = tuple1 + tuple2
print(vowels)
# Output: ('a', 'e', 'i', 'o', 'u')

2. Repetition

Repeat elements:

a = ("tuple",) * 3
print(a)
# Output: ('tuple', 'tuple', 'tuple')

3. Membership

Check if an element exists:

a = (1, 2, 3, 4, 5)
print(6 in a)   # False
print(3 in a)   # True

TUPLE METHODS

Tuples have only two built-in methods:

1. count()

Returns how many times an element appears.

a = ("m", "e", "o", "e", "z")
print(a.count("m"))  # 1
print(a.count("e"))  # 2

2. index()

Returns the position of an element (first occurrence).

a = ("m", "e", "o", "e", "z")
print(a.index("o"))  # 2
print(a.index("e"))  # 1

WHEN TO USE TUPLES?

• When you need fixed data that should not change.

• Tuples can be used as dictionary keys (lists can’t).

• Useful for storing GPS coordinates like latitude and longitude (which should never change).

TUPLE UNPACKING

Tuple unpacking allows assigning values to multiple variables in one line.

person = ("John", 20, "Degree Student")
name, age, job = person

print(name)  # John
print(age)   # 20
print(job)   # Degree Student

It can even work with flexible unpacking:

numbers = (100, 101, 108, 130, 15)
a, *b, c = numbers

print(a)  # 100
print(b)  # [101, 108, 130]
print(c)  # 15

LISTS VS TUPLES

PRACTICE

Try the following exercises:

1. Create a tuple of length 9 with any elements.

2. Retrieve the 4th element.

3. Retrieve elements from index 3 to 7.

4. Return the index of any element.

5. Use the count() method on any element.

💡 For extra clarity: repeat the same with a list, then convert it into a tuple and compare.

CONCLUSION

Thank you for reading this article! 🙌
If you found it helpful, consider subscribing to the newsletter and sharing it with friends who might benefit from it. I’d also love to hear your thoughts, ideas, or feedback — feel free to reach out anytime.

That’s where Python dictionaries come in!

What is a Dictionary?

A dictionary in Python is a collection of key-value pairs.

• The key is like a unique label.

• The value is the data attached to that label.

Think of it as a real dictionary: the word is the key, and its definition is the value.

# Example
student = {
    "name": "Lucky",
    "age": 21,
    "course": "AI"
}
print(student)

Output:

{'name': 'Lucky', 'age': 21, 'course': 'AI'}

Why Use Dictionaries?

• Quick lookups: Access values directly using keys.

• Organized: Keeps data in pairs, making it easy to understand.

• Flexible: Can store numbers, strings, lists, or even other dictionaries as values.

Creating a Dictionary

You can create a dictionary using curly braces {}:

# Empty dictionary
my_dict = {}

# Dictionary with some data
fruits = {"apple": 2, "banana": 5, "orange": 3}
print(fruits)

Accessing Data

To get a value, use its key:

print(fruits["apple"])   # Output: 2

But be careful! If the key doesn’t exist, Python throws an error.
To avoid that, use .get():

print(fruits.get("mango"))   # Output: None

Adding and Updating Data

You can easily add new pairs or update existing ones:

fruits["mango"] = 10    # Add new key-value pair
fruits["apple"] = 4     # Update value of 'apple'
print(fruits)

Removing Data

Dictionaries also allow you to remove pairs:

fruits.pop("banana")    # Removes 'banana'
print(fruits)

fruits.clear()          # Removes everything
print(fruits)

Useful Dictionary Methods

Here are a few handy ones:

student.keys()    # All keys
student.values()  # All values
student.items()   # All key-value pairs

Wrap-Up 🎁

Dictionaries are powerful tools in Python for managing data in a structured way.

• They store data as key-value pairs.

• You can add, update, and remove items easily.

• They make your code cleaner and more readable.

Next time you’re working on a project, ask yourself: “Would this data make more sense as a dictionary?” Chances are, the answer will be yes!

When you start programming, you’ll quickly realize you need a way to store more than one value in a single variable.
For example: instead of creating 10 separate variables for 10 fruits, you can just use a list.

In Python, lists are like containers where you can store multiple items — numbers, strings, or even other lists — all in one place. And the best part? Lists are mutable — which means you can change them!

1. Creating Your First List

You can make an empty list—or load it right up with a few items:

# Empty list
my_list = []

# A list with some items
fruits = ["apple", "banana", "cherry"]

# Mixed kinds of data side by side
mixed = [1, "hello", 3.14, True]

2. Seeing Inside Your List (Indexing)

Just like books on a shelf, every item has a spot—starting from 0 (just like how we saw in the strings article.)

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

print(fruits[0])   # apple
print(fruits[1])   # banana
print(fruits[-1])  # cherry

That -1 grabs you the last item—handy when you don’t know how many are inside.

3. Changing Things Up

Unlike strings, you can change lists. Let’s swap one fruit for another:

fruits = ["apple", "banana", "cherry"]
fruits[1] = "mango"
print(fruits)  # ['apple', 'mango', 'cherry']

4. Adding More Goodies

Want to expand your list? You’ve got options:

fruits = ["apple", "banana", "cherry"]
fruits.append("orange")         # Adds at the end
fruits.insert(1, "grape")       # Places it in position 1
fruits.extend(["kiwi", "melon"])  # Adds several at once
print(fruits) # ['apple', 'grape', 'banana', 'cherry', 'orange', 'kiwi', 'melon']

5. Removing Items—With Care

Lists can lose items too—pick whichever method suits your need:

fruits = ["apple", "grape", "banana", "cherry", "orange", "kiwi", "melon"]
fruits.remove("melon")  # Remove by value
fruits.pop(2)           # Remove by position
del fruits[0]           # Delete specific spot
print(fruits)           # ['grape', 'cherry', 'orange', 'kiwi']
fruits.clear()          # Empty the whole list
print(fruits)           # []

6. Seeing a Slice of the List (Slicing)

Want part of your list? Slicing gives you that:

It will return the range of values that are mentioned as indices in the square braces.

And while mentioning the index value the left side value of colon is used as the starting position and the right side value of colon is used as the stopping index and this index will not be considered.

For example if we give as list1[2:5] then it will return the list1 values that are present in the indexes 2,3,4

numbers = [0, 1, 2, 3, 4, 5]
print(numbers[1:4])   # [1, 2, 3]
print(numbers[:3])    # [0, 1, 2]
print(numbers[::2])   # [0, 2, 4]

7. Handy List Methods

These are daily helpers worth knowing:

numbers = [3, 1, 4, 1, 5, 9]

numbers.sort()             # Order the list
numbers.reverse()          # Flip it backward
print(numbers.index(4))    # Find where 4 is
print(numbers.count(1))    # How many 1s?
copy_list = numbers.copy() # Make a safe copy

Conclusion

Lists are one of the most powerful and flexible tools in Python.
They let you store, modify, and organize data with ease — and you’ll be using them in almost every Python program you write.

Tip: Practice by making small programs that store multiple items in a list, like a grocery list or a favorite movies list.

As we have already discussed in the earlier article on various datatypes, str is a datatype used for storing characters and words.

A string is a collection of characters. For example, the word "Python" is a sequence of the characters "P", "y", "t", "h", "o", "n". Strings are considered immutable, i.e., once a string is created, we cannot change it directly; we have to create a new string to make changes to the original string.

The position of the characters in a string starts from zero. For example, in the word "Python":

"P" → 0
"y" → 1
"t" → 2
"h" → 3
"o" → 4
"n" → 5

Creating Strings

We can create strings in Python using:

1. Single quotes

2. Double quotes

3. Triple quotes

1. Single quotes:

We can create strings by placing the value inside single quotes.
Example:

name = 'Python'
print(name)
# Output - Python

2. Double quotes:

We can create strings by placing the value inside double quotes.
Example:

name = "Python"
print(name)
# Output - Python

3. Triple quotes:

Sometimes we need to create strings that span multiple lines. In such cases, we use triple quotes.
Example:

a = """Welcome to the article
In this article, we will learn
about strings and also
different methods"""
print(a)

Output:

Welcome to the article
In this article, we will learn
about strings and also
different methods

Note: While using multi-line strings, make sure you are assigning them to a variable; otherwise, they will be treated as comments.

Reading Input from the User

We can read text from the user using the input() function:

name = input("Enter your name: ")
print(f"Hello, {name}")

Example Output:

Enter your name: Prajitha
Hello, Prajitha

a = int(input("Enter a value: "))
print(a)

Example Output:

Enter a value: 1
1

If we do not specify a datatype when taking input, Python treats it as a string by default. If we want to take an integer input, we must explicitly cast it using int(), as in the second example.

The text inside the quotes of the input() function appears on the screen as a prompt. It is optional—if you don’t want a prompt, you can simply write:

a = int(input())
print(f"a : {a}")

1
a : 1

Concatenation

As mentioned earlier, strings are immutable. To add two or more strings, we use concatenation, which creates a new string:

str1 = "Hello"
str2 = "World"
str3 = str1 + " " + str2
print(str3)  # Output - Hello World

String Methods

Here are some commonly used string methods:

1. upper()

2. lower()

3. capitalize()

4. title()

5. swapcase()

6. find()

7. index()

8. replace()

9. strip()

10. split()

11. startswith()

12. endswith()

13. isalnum()

14. isalpha()

15. isdigit()

16. islower()

17. isupper()

18. len()

Let’s look at them in detail:

1. upper()

Converts text to uppercase.

a = "string methods"
print(a.upper())  # Output - STRING METHODS

2. lower()

Converts text to lowercase.

a = "STRING METHODS"
print(a.lower())  # Output - string methods

3. capitalize()

Capitalizes the first letter and converts all other letters to lowercase.

a = "heLLo WOrld"
print(a.capitalize())  # Output - Hello world

4. title()

Capitalizes the first letter of every word into uppercase.

a = "converts first character into uppercase"
print(a.title())  # Output - Converts First Character Into Uppercase

5. swapcase()

Swaps uppercase letters to lowercase and vice versa.

text = "Swaps tHE caSES"
print(text.swapcase())  # Output - sWAPS The CAses

6. find()

Finds the position or index of a character or substring. Returns -1 if not found.

text = "Finds the position of a letter"
print(text.find("p"))    # Output - 10
print(text.find("the"))  # Output - 6
print(text.find("x"))    # Output - -1

7. index()

Similar to find(), but raises an error if the substring is not found.

text = "Finds the position of a letter"
print(text.index("F"))         # Output - 0
print(text.index("position"))  # Output - 10
print(text.index("x"))         # Raises ValueError

8. replace()

Replaces a substring with another.

text = "I love C"
print(text.replace("C", "Python"))  # Output - I love Python

9. strip()

Removes leading and trailing spaces.

text = "      Python      "
print(text.strip())  # Output - Python

10. split()

Splits the string based on a delimiter.

text = "I am 20 years old"
print(text.split())  # Output - ['I', 'am', '20', 'years', 'old']

text = "a#b#c#d#e"
print(text.split("#"))  # Output - ['a', 'b', 'c', 'd', 'e']

11. startswith()

Checks if a string starts with a specific substring.

text = "Python has a simple syntax to code"
print(text.startswith("C"))      # Output - False
print(text.startswith("Python")) # Output - True

12. endswith()

Checks if a string ends with a specific substring.

text = "Python has a simple syntax to code"
print(text.endswith("program")) # Output - False
print(text.endswith("code"))    # Output - True

13. isalnum()

Returns True if the string contains only letters and numbers.

a = "Python3"
print(a.isalnum())  # Output - True

a = "Python 3"
print(a.isalnum())  # Output - False

14. isalpha()

Returns True if the string contains only letters.

a = "Python3"
print(a.isalpha())  # Output - False

a = "Python"
print(a.isalpha())  # Output - True

15. isdigit()

Returns True if the string contains only digits.

a = "A123"
print(a.isdigit())  # Output - False

a = "1234"
print(a.isdigit())  # Output - True

16. isupper()

Returns True if all characters are uppercase.

text = "PYTHON"
print(text.isupper())  # Output - True

17. islower()

Returns True if all characters are lowercase.

text = "python"
print(text.islower())  # Output - True

18. len()

Returns the number of characters in a string.

text = "Prajitha"
print(len(text))  # Output - 8

Summary

Strings in Python are just pieces of text — like words, sentences, or even a single character. You can make them using single quotes, double quotes, or triple quotes (for multi-line text). Since strings are immutable (they can’t be changed directly), Python gives us lots of handy built-in methods to work with them. You can change their case (upper(), lower()), make them pretty (capitalize(), title()), find words or letters (find(), index()), replace text (replace()), clean up spaces (strip()), split them into parts (split()), or check what they’re made of (isalnum(), isalpha(), isdigit()). Mastering these tools will make working with text in Python a lot easier and way more fun!

Note:
The best way to master strings is by practicing them in different ways — try out the examples, mix them up, and create your own variations. Python has many other string functions beyond the ones listed here, so feel free to explore the documentation and experiment if you’re curious. The more you practice, the more comfortable and creative you’ll get with strings!

🧠 What Are Comments?

Comments are extremely useful while developing code. They act like little notes or explanations you can leave for yourself or others, especially when revisiting your code after days, months, or even years.

As your code grows into hundreds or thousands of lines, it becomes harder to remember why you wrote a particular line. That's where comments come in handy.

👉 Important: Comments are only visible to you (the reader) and are ignored by Python during execution.

There are two types of comments in Python:

1. Single-line Comment

2. Multi-line Comment

🟩 1. Single-line Comments

Single-line comments are used when your comment fits in a single line. You can also use them to temporarily disable a line of code (helpful during testing or debugging).

✅ To write a single-line comment, use the # symbol.

📌 Examples:

# This is a comment
print("Hello")
# Output: Hello

print("Comments Tutorial")  # This is also a comment
# Output: Comments Tutorial

# This is line 1 comment
# This is line 2 comment
# This is line 3 comment
a = 10
print(a)
# Output: 10

🟨 2. Multi-line Comments

Multi-line comments are useful when your explanation takes up more than one line. Instead of writing # before every line, you can use triple quotes (''' or """).

📌 Example with triple single quotes:

'''
This is line 1 comment
This is line 2 comment
This is line 3 comment
'''

📌 Example with triple double quotes:

"""
This is line 1 comment
This is line 2 comment
This is line 3 comment
"""

⚠️ Note: Make sure the quotes that you are using are straight quotes ("") instead of (““).

🖨️ What Is the Print Statement?

The print() function is used to display output in Python. There are multiple ways to use it:

✅ 1. Basic Printing

a = 10
print(a)
# Output: 10

✅ 2. With Descriptive Text

a = 10
print("a:", a)
# Output: a: 10

Adding a label helps make the output more understandable.

✅ 3. Using f-Strings (Formatted Strings)

This is a modern and readable way to format output in Python.

name = "Prajitha"
print(f"Name: {name}")
# Output: Name: Prajitha

✅ Just add an f before the string and wrap variables inside {} to include them in the output.

✅ Conclusion

That’s it for comments and print statements — two simple yet powerful tools to make your code cleaner, more understandable, and easier to debug.

Practice writing your own examples with comments and print statements — you'll thank yourself later when revisiting your code!

To understand clearly about variables, let us consider an example. In our college, during any exam registration or anything just like how we give our name in the name column, or our roll number in the roll number column — variables are used to store a value.

Example :

roll = 11  
name = "prajitha"

There are different types of values that are present — for example, our name is considered to be a string since it is a word, our roll number will be an int since it consists of integer values and so on. All these types like string, integer are called as data types.

Data Types in Python:

• int – integer values

• float – decimal values

• str – short for string, words or sentences or even letters

• bool – True, False etc

Apart from these, there are a few more important data types in Python which we will learn in upcoming articles:

• list – collection of multiple values in square brackets

• tuple – similar to list but immutable (cannot change)

• dict – key-value pairs used to store structured data

• set – collection of unique values

We do not need to use data types in Python, we can just give a value to a variable like:

variable_name = variable_value

But there are some rules to name a variable:

• Variable names consist of only capital or small case letters, numbers, and underscore (_) only.

• The starting letter of a variable must be a letter or an underscore, it should not start with a number.

• There should not be any spaces while writing the variables.

• Variable names are case-sensitive.

Examples:

first name ❌    first_name ✅  
1st ❌           first ✅  
_value ✅        myvar, MYVAR, MyVar, myVar — all these four variable names are distinct.

While giving the values to the variables we can assign only a single value to a variable name.

And also while giving a string value or a character value, we have to give them in single or double quotes.

name = "Prajitha" or name = 'Prajitha'  
letter = "A" or letter = 'A'  
letter = A ❌ invalid

To assign an integer or a float value or any other values to a variable we do not need to specify the datatype. We can just assign them directly.

a = 10  
b = 1.5

After assigning a value to a variable, we can use a function in Python that tells us the datatype of that variable’s value.

The function that is used is called as type().

Examples:

group = "BSc"
print(type(group))  
# output - <class 'str'>

roll = 11
print(type(roll))  
# output - <class 'int'>

grade = "8.5"
print(type(grade))  
# output - <class 'str'>

In the third example if you observe, even if we have given 8.5 as value, it showed that the datatype is str, because we have given 8.5 in double quotes. So anything that is mentioned inside single or double quotes is considered as string.

We can also convert the datatype of one variable into another datatype like converting a variable of datatype int to a datatype str. This process of converting is called as type casting.

It is very easy to perform type casting in Python.

Examples:

value_before = 5.2
print(type(value_before))  
# output - <class 'float'>

value_after = int(value_before)
print(value_after)  
# output - 5

print(type(value_after))  
# output - <class 'int'>

value_before = "123"
print(type(value_before))  
# output - <class 'str'>

value_after = int(value_before)
print(type(value_after))  
# output - <class 'int'>

s = "abc"
int(s)
# output - ❌ It will show error as we are not performing type casting correctly.

In upcoming articles, we will cover:

• How to use list, tuple, dict, and set in real life

• How to work with multiple variables at once

• Advanced type conversions and error handling

Summary:

• Variables are used to store a value in Python.

• Data types tell us what kind of value the variable holds.

• Python allows us to assign values without specifying the data type.

• Use type() to check the data type.

• Use type casting to convert one data type into another.

• Follow naming rules while creating variables.

💡 Terminology Alert!

• High-Level Language: Language that is understandable by humans (e.g., Python, Java)

• Low-Level Language: Language understandable by machines — usually binary (0’s and 1’s)

🤔 But How Does This Translation Happen?

This process of converting high-level language to low-level (machine) language is called compilation.

Now let’s understand how Python handles this process step by step.

🔁 Python Compilation Stages (5-Step Process)

1. Source Code

2. Python Interpreter

3. Bytecode

4. Python Virtual Machine (PVM)

5. Output

🔹 1. Source Code

This is the code written by a developer — it’s the .py file you create.

Just like we save images as .jpg or .png, Python source code must be saved with the .py extension.

Example:

print("Hello, Python!!")

Save this as hello.py.

🔸 2. Python Interpreter

The interpreter is what starts the process.

• It reads the source code

• Compiles it to an intermediate format called bytecode, which is not human-readable but still not binary.

• Then passes it on to the next stage

This is what allows your Python code to be run and understood by your system.

🔹 3. Bytecode (.pyc)

Once compiled, Python generates a bytecode file automatically.

• It will be saved as a .pyc file

• Stored inside a folder called __pycache__

• Example: __pycache__/hello.cpython-311.pyc

This file contains a translated version of your original code — not in binary, but in a form Python can process faster.

🧠 Why it's useful:
If you run the same program multiple times, Python won’t compile it again — it just reuses the .pyc file, saving time.

🔸 4. Python Virtual Machine (PVM)

The Python Virtual Machine now steps in.

• It reads and executes the bytecode

• Executes it line by line

• This is where all the actual actions (like printing, calculations, etc.) happen

You can think of the PVM as Python’s runtime engine.

🔹 5. Output

After all the behind-the-scenes work is done, Python finally shows you the output on your screen.

In our case:

Hello, Python!!

🧪 Let’s See This in Action

print("Hello, Python!!")

1. Save this code as hello.py

2. Run it using:

    python hello.py
   

3. Python creates a .pyc file like:
   __pycache__/hello.cpython-311.pyc

4. The PVM executes the bytecode

5. Output appears:

    Hello, Python!!
   

🔁 In Short

Your code (.py)

↓

Compiled to Bytecode (.pyc)

↓

Run by PVM

↓

Output on Screen

🧠 Final Thoughts

Knowing what happens behind the scenes gives you more control and confidence as a Python programmer. You’re not just writing code — you understand how it runs.

In the next article, we’ll take our first step into actual Python coding with variables and data.

Thanks for reading! 😊