DEV Community: Ramesh S

Python for Beginners — Part 8: Object-Oriented Python

Ramesh S — Tue, 23 Jun 2026 04:02:18 +0000

Part 8 of an 8-part beginner-friendly series on learning Python from scratch.

Congratulations — you've made it to the final part!

Everything you've learned — variables, control flow, collections, functions, file I/O, error handling — can be organized into classes and objects. This is object-oriented programming (OOP), and it's how professional Python code is written.

OOP isn't required to write working programs, but it's essential for writing code that scales, is maintainable, and professional. This final article brings everything together.

Classes and Objects

A class is a blueprint for creating objects. An object is an instance of that class. Think of a class like a cookie cutter and objects like the cookies it produces.

Defining a class

class Person:
    pass

# Create an object (instance)
person = Person()
print(person)  # <__main__.Person object at 0x...>

class Person: defines a class. person = Person() creates an object from that class.

The `init` Method and `self`

The __init__ method runs automatically when you create an object. It's where you initialize the object's data.

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

person = Person("Ramesh", 25)
print(person.name)  # Ramesh
print(person.age)   # 25

self represents the object itself. When you write self.name = name, you're saying "this object's name attribute equals the name I was given."

Think of it this way:

name (parameter) is the input
self.name (attribute) is the object's stored data

Creating multiple objects

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

person1 = Person("Ramesh", 25)
person2 = Person("Priya", 23)

print(person1.name, person1.age)  # Ramesh 25
print(person2.name, person2.age)  # Priya 23

Each object is independent. person1.name is separate from person2.name.

Methods

A method is a function inside a class. Methods operate on the object's data:

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

    def greet(self):
        return f"Hello, I'm {self.name}"

    def have_birthday(self):
        self.age += 1

person = Person("Ramesh", 25)
print(person.greet())       # Hello, I'm Ramesh
person.have_birthday()
print(person.age)           # 26

Call methods with dot notation: person.greet(). The self parameter is passed automatically — you don't type it.

Instance vs Class Variables

Instance variables are unique to each object. Class variables are shared by all objects of that class:

class Dog:
    species = "Canis familiaris"  # Class variable

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

dog1 = Dog("Buddy")
dog2 = Dog("Max")

print(dog1.name)           # Buddy (unique to dog1)
print(dog2.name)           # Max (unique to dog2)
print(Dog.species)         # Canis familiaris (shared)
print(dog1.species)        # Canis familiaris (accessible via instance too)

Use class variables for data shared by all instances. Use instance variables for data unique to each instance.

Inheritance

Inheritance lets you create a new class based on an existing class. The new class inherits methods and attributes from the parent:

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

    def speak(self):
        return f"{self.name} makes a sound"

class Dog(Animal):
    def speak(self):
        return f"{self.name} barks"

class Cat(Animal):
    def speak(self):
        return f"{self.name} meows"

dog = Dog("Buddy")
cat = Cat("Whiskers")

print(dog.speak())  # Buddy barks
print(cat.speak())  # Whiskers meows

Dog and Cat inherit from Animal and override the speak() method. This is called method overriding.

Using `super()`

Call the parent class's method with super():

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

    def describe(self):
        return f"{self.name} is an animal"

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # Call parent's __init__
        self.breed = breed

    def describe(self):
        parent_desc = super().describe()  # Call parent's describe
        return f"{parent_desc} and is a {self.breed}"

dog = Dog("Buddy", "Golden Retriever")
print(dog.describe())  # Buddy is an animal and is a Golden Retriever

super() lets you access the parent class without repeating code.

Polymorphism

Polymorphism means "many shapes" — the same function name works differently depending on the object type:

class Dog:
    def speak(self):
        return "Woof!"

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

class Cow:
    def speak(self):
        return "Moo!"

animals = [Dog(), Cat(), Cow()]

for animal in animals:
    print(animal.speak())

# Output:
# Woof!
# Meow!
# Moo!

Each animal speaks differently, but you call the same method. This is polymorphism in action.

Encapsulation

Encapsulation is the idea of bundling data and methods together, and controlling access to them. Python uses naming conventions:

public_attribute — accessible from outside (convention)
_private_attribute — intended private (convention, not enforced)
__really_private — name-mangled, harder to access (enforced)

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # "Private"

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

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

    def get_balance(self):
        return self.__balance

account = BankAccount(1000)
account.deposit(500)
print(account.get_balance())  # 1500

# Can't access directly:
# print(account.__balance)  # AttributeError (name-mangled)

The double underscore (__) makes the attribute private. Access it through methods instead. This prevents accidental misuse.

Dunder Methods

Dunder methods (double underscore) are special methods Python calls automatically. Here are the most important:

`str` and `repr`

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

    def __str__(self):
        return f"{self.name} ({self.age})"

    def __repr__(self):
        return f"Person('{self.name}', {self.age})"

person = Person("Ramesh", 25)
print(str(person))   # Ramesh (25) — human-readable
print(repr(person))  # Person('Ramesh', 25) — for debugging

__str__ is for end users. __repr__ is for developers.

`len`

class ShoppingCart:
    def __init__(self):
        self.items = []

    def add(self, item):
        self.items.append(item)

    def __len__(self):
        return len(self.items)

cart = ShoppingCart()
cart.add("apple")
cart.add("banana")
print(len(cart))  # 2

Now len(cart) returns the number of items.

`eq`

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

    def __eq__(self, other):
        return self.name == other.name

person1 = Person("Ramesh")
person2 = Person("Ramesh")
print(person1 == person2)  # True (compares names)

Define how == works for your objects.

Properties and Getters/Setters

Properties let you access attributes like data, but with method-like control:

class Person:
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        if len(value) > 0:
            self._name = value

person = Person("Ramesh")
print(person.name)     # Ramesh (getter)
person.name = "Priya"  # Setter
print(person.name)     # Priya

The @property decorator makes name act like an attribute but run validation code.

Practical Examples

Example 1: User class

class User:
    def __init__(self, username, email):
        self.username = username
        self.email = email
        self.created_at = datetime.now()

    def __str__(self):
        return f"User({self.username})"

    def change_email(self, new_email):
        if "@" in new_email:
            self.email = new_email
        else:
            raise ValueError("Invalid email")

user = User("ramesh", "ramesh@example.com")
print(user)  # User(ramesh)
user.change_email("ramesh.new@example.com")

Example 2: Inheritance with Bank Accounts

class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount

class SavingsAccount(Account):
    def __init__(self, owner, balance, interest_rate):
        super().__init__(owner, balance)
        self.interest_rate = interest_rate

    def apply_interest(self):
        self.balance *= (1 + self.interest_rate)

savings = SavingsAccount("Ramesh", 1000, 0.05)
savings.deposit(500)
savings.apply_interest()
print(savings.balance)  # 1575.0

Example 3: Polymorphism with shapes

class Shape:
    def area(self):
        raise NotImplementedError

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

shapes = [Circle(5), Rectangle(4, 6)]
for shape in shapes:
    print(f"Area: {shape.area()}")

# Output:
# Area: 78.5
# Area: 24

Why This Matters

OOP is how professional code is organized. Without it, programs become tangled messes of functions and variables. With OOP, you group related data and behavior together into classes, making code:

Reusable — inheritance lets you extend existing code
Maintainable — encapsulation hides complexity
Scalable — polymorphism lets you add new types easily
Clear — objects represent real-world concepts

The most common beginner mistakes:

Forgetting self in methods
Confusing __init__ (constructor) with class definition
Not using inheritance when it makes sense
Overcomplicating with too many classes (start simple)
Breaking encapsulation with direct attribute access

Your Journey is Complete

You've now learned:

Syntax and basics (Parts 1–2)
Working with text and logic (Parts 3–4)
Organizing data (Part 5)
Organizing code (Part 6)
Working in the real world (Part 7)
Professional code structure (Part 8: OOP)

You have all the fundamental skills of a Python programmer. Where you go from here is up to you — web development, data science, automation, games, machine learning — Python is everywhere.

What's Next

You've completed the 8-part beginner series. From here:

Web development: Flask or Django frameworks
Data science: Pandas, NumPy, Matplotlib
Automation: Scripts to automate tasks
Games: Pygame library
Machine learning: Scikit-learn, TensorFlow
Advanced Python: Decorators, metaclasses, async/await

The fundamentals you've learned here apply to everything. Pick a project that excites you and build it.

Python for Beginners — Part 7: Modules, Errors & Files

Ramesh S — Tue, 23 Jun 2026 03:54:20 +0000

Part 7 of a beginner-friendly series on learning Python from scratch.

In Part 6, we learned to write reusable functions. Now it's time to make those functions work in the real world: reading data from files, handling things when they go wrong, and using code other people have written.

This is where Python transitions from "learning exercises" to "actual programs." Real programs read files, talk to the internet, handle unexpected input, and use libraries to solve complex problems.

Modules and Imports

A module is a file containing Python code that you can reuse. Python comes with a huge standard library of modules, and you can also install external ones.

Using the math module

import math

print(math.sqrt(16))      # 4.0
print(math.pow(2, 3))     # 8.0
print(math.pi)            # 3.14159...
print(math.ceil(4.3))     # 5 (round up)
print(math.floor(4.7))    # 4 (round down)

import math loads the math module. You access its functions and constants with dot notation: math.sqrt(), math.pi, etc.

Importing specific items

If you only need a few things, import them directly:

from math import sqrt, pi

print(sqrt(16))   # 4.0 (no need for math.)
print(pi)         # 3.14159...

Now you use sqrt() directly, not math.sqrt().

Aliasing imports

Use as to give a module a shorter name:

import math as m

print(m.sqrt(16))  # 4.0

Or alias specific items:

from math import sqrt as square_root

print(square_root(16))  # 4.0

Working with datetime

The datetime module is essential for handling dates and times:

from datetime import datetime, timedelta

# Get current date and time
now = datetime.now()
print(now)  # 2024-06-23 14:30:45.123456

# Create a specific date
birthday = datetime(1999, 5, 15)
print(birthday)  # 1999-05-15 00:00:00

# Format as string
print(now.strftime("%Y-%m-%d"))  # 2024-06-23
print(now.strftime("%A, %B %d"))  # Sunday, June 23

# Time differences
future = now + timedelta(days=30)
print(future)  # Date 30 days from now

Working with JSON

JSON (JavaScript Object Notation) is a standard format for exchanging data. Python dictionaries map perfectly to JSON:

import json

# Convert Python dict to JSON string
person = {
    "name": "Ramesh",
    "age": 25,
    "city": "Chennai",
    "hobbies": ["reading", "coding", "gaming"]
}

json_string = json.dumps(person)
print(json_string)
# {"name": "Ramesh", "age": 25, "city": "Chennai", "hobbies": ["reading", "coding", "gaming"]}

# Convert JSON string back to Python dict
parsed = json.loads(json_string)
print(parsed["name"])  # Ramesh

Reading and writing JSON files:

import json

# Write to file
data = {"name": "Ramesh", "age": 25}
with open("data.json", "w") as file:
    json.dump(data, file)

# Read from file
with open("data.json", "r") as file:
    data = json.load(file)
    print(data)

Regular Expressions (Regex)

Regex is a language for pattern matching in text. It's powerful but takes time to master. Here are common patterns:

import re

text = "My phone is 555-1234 and email is user@example.com"

# Find a pattern
phone = re.search(r"\d{3}-\d{4}", text)
if phone:
    print(phone.group())  # 555-1234

# Find all matches
emails = re.findall(r"[\w.-]+@[\w.-]+\.\w+", text)
print(emails)  # ['user@example.com']

# Replace
cleaned = re.sub(r"\d", "X", text)
print(cleaned)  # Phone is XXX-XXXX...

# Check if pattern matches
if re.match(r"^\d+$", "12345"):
    print("It's all digits")

Regex patterns (a few common ones):

\d — any digit (0-9)
\w — any word character (letter, digit, underscore)
\s — any whitespace
. — any character
* — zero or more
+ — one or more
? — zero or one
{n} — exactly n times
^ — start of string
$ — end of string
[abc] — a, b, or c

Regex is complex; this is just an introduction. Most beginners use regex sparingly and look up patterns when needed.

File Input and Output

Reading files

# Simple read
with open("myfile.txt", "r") as file:
    content = file.read()
    print(content)

# Read line by line
with open("myfile.txt", "r") as file:
    for line in file:
        print(line.strip())  # strip() removes newline

# Read all lines as a list
with open("myfile.txt", "r") as file:
    lines = file.readlines()
    print(lines[0])  # First line

The with statement is crucial — it automatically closes the file when you're done, even if an error occurs.

Writing files

# Write (overwrites if file exists)
with open("output.txt", "w") as file:
    file.write("Hello, World!\n")
    file.write("Second line\n")

# Append (add to end of file)
with open("output.txt", "a") as file:
    file.write("Third line\n")

Working with file paths

import os

# Check if file exists
if os.path.exists("myfile.txt"):
    print("File found")

# Get file size
size = os.path.getsize("myfile.txt")
print(f"File size: {size} bytes")

# List files in directory
files = os.listdir(".")
print(files)

# Create directory
os.makedirs("my_folder", exist_ok=True)

# Delete file
os.remove("myfile.txt")

Exception Handling

Real programs fail sometimes — bad file paths, network errors, invalid input. Handle these gracefully with try/except:

try:
    # Code that might fail
    number = int("not a number")
except ValueError:
    print("That's not a valid number")

If int() fails, Python catches the ValueError and runs the except block instead of crashing.

Multiple exceptions

try:
    file = open("missing.txt", "r")
    number = int(file.read())
except FileNotFoundError:
    print("File doesn't exist")
except ValueError:
    print("File contains non-numeric data")
except Exception as e:
    print(f"Something went wrong: {e}")

Handle specific errors first, then generic ones. Exception catches everything.

Try, except, else, finally

try:
    file = open("data.txt", "r")
    data = file.read()
except FileNotFoundError:
    print("File not found")
else:
    # Runs if no exception occurred
    print(f"Successfully read {len(data)} characters")
finally:
    # Always runs, useful for cleanup
    print("Done")

try — code that might fail
except — what to do if it fails
else — what to do if it succeeds
finally — always runs (cleanup)

Raising exceptions

You can raise exceptions yourself:

def validate_age(age):
    if age < 0:
        raise ValueError("Age cannot be negative")
    if age > 150:
        raise ValueError("Age seems unrealistic")
    return True

try:
    validate_age(-5)
except ValueError as e:
    print(f"Invalid input: {e}")

Installing External Libraries with pip

The pip package manager lets you install libraries others have written:

pip install requests      # Install the requests library
pip install numpy pandas  # Install multiple packages
pip install requests==2.28.0  # Install specific version
pip list                  # Show installed packages
pip uninstall requests    # Remove a package

Once installed, use them like built-in modules:

import requests

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

Popular libraries for beginners:

requests — make web requests
numpy — numerical computing
pandas — data analysis
matplotlib — plotting and visualization
flask — build web applications

Practical Examples

Example 1: Read and count words

def count_words(filename):
    try:
        with open(filename, "r") as file:
            content = file.read()
            words = content.split()
            return len(words)
    except FileNotFoundError:
        print(f"Error: {filename} not found")
        return 0

count = count_words("myfile.txt")
print(f"Total words: {count}")

Example 2: Save and load JSON data

import json

def save_contacts(contacts, filename):
    with open(filename, "w") as file:
        json.dump(contacts, file, indent=2)

def load_contacts(filename):
    try:
        with open(filename, "r") as file:
            return json.load(file)
    except FileNotFoundError:
        return []

# Save
contacts = [
    {"name": "Ramesh", "phone": "555-1234"},
    {"name": "Priya", "phone": "555-5678"}
]
save_contacts(contacts, "contacts.json")

# Load
loaded = load_contacts("contacts.json")
print(loaded)

Example 3: Extract data with regex

import re

def extract_emails(text):
    pattern = r"[\w.-]+@[\w.-]+\.\w+"
    return re.findall(pattern, text)

text = "Contact me at john@example.com or jane.doe@company.co.uk"
emails = extract_emails(text)
print(emails)  # ['john@example.com', 'jane.doe@company.co.uk']

Why This Matters

File I/O and exception handling are what separate learning exercises from real programs. Every professional program reads data from files or the internet, handles errors gracefully, and uses external libraries. Modules let you leverage thousands of hours of other people's work instead of writing everything yourself.

The most common beginner mistakes:

Forgetting to close files (use with — it's mandatory style)
Not handling file not found errors
Assuming regex patterns are simpler than they are
Catching generic Exception instead of specific errors
Not installing libraries with pip correctly

What's Next

In Part 8, the final part, we'll explore object-oriented programming — classes, inheritance, and polymorphism. OOP is how professional Python code is structured, and everything you've learned so far will come together.

This is Part 7 of an 8-part beginner Python series. Catch up on Part 1: Getting Started & Syntax, Part 2: Variables, Data Types & Numbers, Part 3: Strings & Booleans, Part 4: Operators & Control Flow, Part 5: Collections, and Part 6: Functions.

Python for Beginners — Part 6: Functions

Ramesh S — Tue, 23 Jun 2026 03:43:55 +0000

Part 6 of a beginner-friendly series on learning Python from scratch.

In Part 5, we learned to organize data with lists, dictionaries, and other collections. Now it's time to organize our code itself.

A function is a reusable block of code that performs a specific task. Instead of writing the same code multiple times, you write it once in a function, then call that function whenever you need it. This is the foundation of writing clean, maintainable programs.

Defining and Calling Functions

The basics

def greet():
    print("Hello, World!")

greet()  # Call the function

Use def to define a function. The function name is followed by parentheses and a colon. The indented block below is the function's body.

When you call the function (by typing its name with parentheses), Python runs the code inside it.

Functions with parameters

Most functions need information to work with. That's what parameters are for:

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

greet("Ramesh")   # Hello, Ramesh!
greet("Priya")    # Hello, Priya!

name is a parameter (placeholder). When you call greet("Ramesh"), name becomes "Ramesh" inside the function.

Multiple parameters:

def add(x, y):
    print(x + y)

add(5, 3)   # 8
add(10, 20) # 30

Return values

A function can calculate something and give the result back to you with return:

def add(x, y):
    return x + y

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

The return statement stops the function and sends a value back. The caller can then use that value.

def greet(name):
    message = f"Hello, {name}!"
    return message

greeting = greet("Ramesh")
print(greeting)  # Hello, Ramesh!

A function can return multiple values as a tuple:

def get_user_info():
    return "Ramesh", 25, "Chennai"

name, age, city = get_user_info()
print(name, age, city)  # Ramesh 25 Chennai

Arguments: Positional vs Keyword

There are two ways to pass values to a function:

Positional arguments

Arguments are matched by position:

def describe(name, age):
    print(f"{name} is {age} years old")

describe("Ramesh", 25)  # Ramesh is 25 years old
describe(25, "Ramesh")  # 25 is Ramesh years old (wrong order, confusing)

Order matters.

Keyword arguments

You can use parameter names to be explicit:

def describe(name, age):
    print(f"{name} is {age} years old")

describe(age=25, name="Ramesh")  # Ramesh is 25 years old
describe(name="Ramesh", age=25)  # Ramesh is 25 years old (order doesn't matter)

Keyword arguments make code clearer and are less error-prone. Mix them freely:

describe("Ramesh", age=25)  # First positional, then keyword

Default Arguments

You can give parameters default values — they're optional:

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

print(greet("Ramesh"))              # Hello, Ramesh!
print(greet("Ramesh", "Hi"))        # Hi, Ramesh!
print(greet("Ramesh", greeting="Hey"))  # Hey, Ramesh!

If the caller doesn't provide greeting, it defaults to "Hello".

Important rule: Parameters with defaults must come after parameters without defaults:

# Correct
def add(x, y, verbose=False):
    result = x + y
    if verbose:
        print(f"{x} + {y} = {result}")
    return result

# Wrong — SyntaxError
def add(x=0, y):
    return x + y

*args — Variable Number of Arguments

Sometimes you want a function to accept any number of arguments. Use *args:

def add_many(*numbers):
    total = 0
    for num in numbers:
        total += num
    return total

print(add_many(1, 2, 3))           # 6
print(add_many(1, 2, 3, 4, 5))     # 15
print(add_many())                  # 0 (no arguments)

*args (the name args is conventional) collects all extra arguments into a tuple. The * unpacks them.

def print_all(*items):
    for item in items:
        print(item)

print_all("apple", "banana", "cherry", 42)
# Prints each on its own line

**kwargs — Keyword Arguments as Dictionary

Similar to *args, use **kwargs to accept any number of keyword arguments:

def make_profile(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

make_profile(name="Ramesh", age=25, city="Chennai")
# Output:
# name: Ramesh
# age: 25
# city: Chennai

**kwargs (convention) collects keyword arguments into a dictionary.

Combining everything

You can use *args and **kwargs together:

def my_function(required, *args, default_arg="default", **kwargs):
    print(f"Required: {required}")
    print(f"Args: {args}")
    print(f"Default: {default_arg}")
    print(f"Kwargs: {kwargs}")

my_function(1, 2, 3, 4, default_arg="custom", extra1="value1", extra2="value2")

# Output:
# Required: 1
# Args: (2, 3, 4)
# Default: custom
# Kwargs: {'extra1': 'value1', 'extra2': 'value2'}

Order: positional, *args, keyword defaults, **kwargs.

Scope and Variable Lifetime

Variables have scope — the region of code where they exist and are accessible.

Local scope

Variables created inside a function only exist inside that function:

def greet():
    message = "Hello"  # Local variable
    print(message)

greet()           # Hello
print(message)    # NameError — message doesn't exist here

Global scope

Variables created outside functions are global:

message = "Hello"  # Global variable

def greet():
    print(message)  # Can access global variables

greet()    # Hello
print(message)  # Hello

Modifying global variables

Be careful — inside a function, assignment creates a local variable:

count = 0

def increment():
    count = count + 1  # UnboundLocalError — trying to use local before assignment
    return count

increment()

To modify a global variable inside a function, use global:

count = 0

def increment():
    global count
    count = count + 1
    return count

increment()
print(count)  # 1

Tip: Generally, avoid modifying global variables. It makes code hard to understand. Instead, pass values in and return values out.

Lambda Functions — Quick Throwaway Functions

A lambda is a tiny anonymous function, useful for one-liners:

square = lambda x: x ** 2
print(square(5))  # 25

Syntax: lambda parameters: expression

Lambda functions are usually passed to other functions. For example, sorted() can take a function that determines the sort order:

people = [
    {"name": "Ramesh", "age": 25},
    {"name": "Priya", "age": 20},
    {"name": "Arun", "age": 30}
]

# Sort by age
sorted_by_age = sorted(people, key=lambda person: person["age"])
print(sorted_by_age)
# [{'name': 'Priya', 'age': 20}, {'name': 'Ramesh', 'age': 25}, {'name': 'Arun', 'age': 30}]

Or with map() to transform a list:

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

Lambda is elegant for simple operations. For anything complex, write a proper function.

Recursion — Functions Calling Themselves

A recursive function calls itself. It's powerful for solving problems that repeat the same pattern at smaller scales.

Every recursive function needs a base case (when to stop) and a recursive case (how to shrink the problem):

def countdown(n):
    # Base case
    if n == 0:
        print("Blastoff!")
        return

    # Recursive case
    print(n)
    countdown(n - 1)

countdown(5)
# Output:
# 5
# 4
# 3
# 2
# 1
# Blastoff!

Without a base case, the function recurses infinitely and crashes:

def bad_countdown(n):
    print(n)
    bad_countdown(n - 1)  # Never stops!

bad_countdown(5)  # RecursionError: maximum recursion depth exceeded

Classic example: Factorial

def factorial(n):
    # Base case
    if n == 0 or n == 1:
        return 1

    # Recursive case
    return n * factorial(n - 1)

print(factorial(5))  # 120 (5 * 4 * 3 * 2 * 1)

Recursion is elegant but can be slow and memory-intensive. Use it when the problem naturally breaks into recursive patterns (like tree structures), not for simple loops.

Generators and Iterators

A generator is a function that yields values one at a time, instead of returning them all at once. Use yield:

def count_up_to(n):
    i = 1
    while i <= n:
        yield i
        i += 1

for num in count_up_to(5):
    print(num)

# Output:
# 1
# 2
# 3
# 4
# 5

The function pauses at yield and resumes where it left off. This is memory-efficient for large datasets:

# Without generator — creates entire list in memory
def range_list(n):
    result = []
    for i in range(n):
        result.append(i)
    return result

# With generator — creates values on-demand
def range_gen(n):
    for i in range(n):
        yield i

# Both work with for loops, but generator is more efficient
for num in range_list(1000000):  # Creates 1 million item list
    print(num)

for num in range_gen(1000000):   # Creates values as needed
    print(num)

Generators are a more advanced topic — understand them conceptually now; you'll use them more as you progress.

Practical Examples

Example 1: Simple calculator

def add(x, y):
    return x + y

def subtract(x, y):
    return x - y

def multiply(x, y):
    return x * y

def divide(x, y):
    if y == 0:
        return "Cannot divide by zero"
    return x / y

print(add(10, 5))       # 15
print(divide(10, 0))    # Cannot divide by zero

Example 2: Processing collections

def find_max(numbers):
    if len(numbers) == 0:
        return None

    max_num = numbers[0]
    for num in numbers:
        if num > max_num:
            max_num = num
    return max_num

print(find_max([3, 7, 2, 9, 1]))  # 9

Example 3: Flexible greeting

def create_greeting(*names, greeting="Hello", punctuation="!"):
    message = f"{greeting}, {', '.join(names)}{punctuation}"
    return message

print(create_greeting("Ramesh", "Priya"))
# Hello, Ramesh, Priya!

print(create_greeting("Alice", "Bob", greeting="Hi", punctuation="?"))
# Hi, Alice, Bob?

Why This Matters

Functions are how you stop repeating yourself. Instead of copying the same code 10 times, you write it once, call it 10 times. This saves time, prevents bugs, and makes changes easier.

The most common beginner mistakes:

Forgetting parentheses when calling a function
Using return to print (they're different — one sends a value back, one displays it)
Trying to use variables defined inside a function outside of it
Infinite recursion (forgetting the base case)
Confusing *args with * unpacking operator

What's Next

In Part 7, we explored with modules, errors, and files — using other people's code, handling problems gracefully, and reading/writing data to disk. Functions you write will often read or write files.

This is Part 6 of an 8-part beginner Python series. Catch up on Part 1: Getting Started & Syntax, Part 2: Variables, Data Types & Numbers, Part 3: Strings & Booleans, Part 4: Operators & Control Flow, and Part 5: Collections.

Python for Beginners — Part 5: Collections

Ramesh S — Mon, 22 Jun 2026 17:42:16 +0000

Part 5 of a beginner-friendly series on learning Python from scratch.

In Part 4, we learned how to make decisions and repeat code with loops. Now we're going to upgrade that power dramatically: instead of working with single values, we'll work with entire collections of data.

This is where Python becomes truly versatile. Collections let you store multiple values in a single variable, organize data logically, and iterate over it with the loops you just learned. Most real programs spend their time managing collections.

Lists — Ordered, Changeable Collections

A list is a container that holds multiple values in a specific order. You can add, remove, or change items after creating the list.

Creating and accessing lists

fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True]

Lists use square brackets and items are separated by commas. Items can be different types.

Access items by their index (position), just like strings:

fruits = ["apple", "banana", "cherry"]
print(fruits[0])    # apple
print(fruits[1])    # banana
print(fruits[-1])   # cherry (last item)

Get the length with len():

print(len(fruits))  # 3

Slicing lists

Just like strings, lists can be sliced:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(numbers[0:3])     # [1, 2, 3]
print(numbers[5:])      # [6, 7, 8, 9, 10]
print(numbers[::2])     # [1, 3, 5, 7, 9] (every 2nd item)

Essential list methods

Lists come with many built-in methods. Here are the most important:

fruits = ["apple", "banana"]

# Add items
fruits.append("cherry")              # Add to the end
fruits.insert(1, "mango")            # Insert at specific position
fruits.extend(["date", "elderberry"]) # Add multiple items

# Remove items
fruits.remove("banana")              # Remove by value
fruits.pop()                         # Remove last item and return it
fruits.pop(0)                        # Remove item at index 0
fruits.clear()                       # Remove all items

# Find and sort
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
print(numbers.count(1))              # 2 (how many 1's)
print(numbers.index(4))              # 2 (position of 4)
numbers.sort()                       # Sort in place: [1, 1, 2, 3, 4, 5, 6, 9]
numbers.reverse()                    # Reverse in place

# Create a copy
numbers_copy = numbers.copy()        # Independent copy

Important: sort() and reverse() change the list itself, not creating a new list. If you want to keep the original:

sorted_numbers = sorted(numbers)     # Returns a new sorted list

Modifying list items

Lists are mutable (changeable):

fruits = ["apple", "banana", "cherry"]
fruits[1] = "blueberry"              # Change the second item
print(fruits)                        # ["apple", "blueberry", "cherry"]

Iterating over lists

Combine lists with the for loops from Part 4:

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

for fruit in fruits:
    print(fruit)

Output:

apple
banana
cherry

List comprehension — concise list creation

List comprehension is a compact way to create a new list by transforming or filtering an existing one:

# Create a list of squares
numbers = [1, 2, 3, 4, 5]
squares = [x**2 for x in numbers]
print(squares)  # [1, 4, 9, 16, 25]

# Filter: only even numbers
evens = [x for x in numbers if x % 2 == 0]
print(evens)    # [2, 4]

# Transform and filter
result = [x * 2 for x in numbers if x > 2]
print(result)   # [6, 8, 10]

Read it as: "Create a list of [transformation] for [each item] in [source list] if [condition]"

List comprehensions are faster and more Pythonic than building lists with loops. They're common in real code.

Tuples — Ordered, Unchangeable Collections

A tuple is like a list, but immutable (unchangeable). Once created, you can't add, remove, or modify items.

Creating tuples

colors = ("red", "green", "blue")
single_item = ("hello",)  # Note the comma — without it, it's just a string
empty = ()

Use parentheses (round brackets). The comma is crucial for single-item tuples.

Accessing and iterating

colors = ("red", "green", "blue")
print(colors[0])      # red
print(colors[-1])     # blue
print(len(colors))    # 3

for color in colors:
    print(color)

Unpacking tuples

Tuples shine when you want to assign multiple values at once:

x, y = (1, 2)
print(x)  # 1
print(y)  # 2

# The parentheses are optional
name, age, city = "Ramesh", 25, "Chennai"
print(name, age, city)  # Ramesh 25 Chennai

# Swap variables easily
a, b = 1, 2
a, b = b, a  # Now a=2, b=1

Why use tuples?

Speed: Slightly faster than lists (minor difference)
Safety: Immutable, can't accidentally modify
Keys in dictionaries: Tuples can be dict keys; lists can't
Function returns: Functions often return tuples of multiple values

def get_user():
    return ("Ramesh", 25, "Chennai")

name, age, city = get_user()

Sets — Unique, Unordered Collections

A set is a collection of unique values with no specific order. Duplicates are automatically removed.

Creating sets

numbers = {1, 2, 3, 4, 5}
unique_letters = {"a", "b", "c", "a"}  # 'a' appears once
print(unique_letters)                   # {'a', 'b', 'c'} (order may vary)

empty_set = set()  # Note: {} creates an empty dict, not a set

Use curly braces. Sets have no indexing — you can't access the first item like you can with lists.

Common set operations

a = {1, 2, 3}
b = {3, 4, 5}

# Union — all items from both sets
print(a | b)        # {1, 2, 3, 4, 5}
print(a.union(b))   # {1, 2, 3, 4, 5}

# Intersection — items in both sets
print(a & b)        # {3}
print(a.intersection(b))  # {3}

# Difference — items in a but not b
print(a - b)        # {1, 2}
print(a.difference(b))    # {1, 2}

# Check membership
print(3 in a)       # True
print(4 in a)       # False

Set methods

numbers = {1, 2, 3}
numbers.add(4)          # Add one item
numbers.update([5, 6])  # Add multiple items
numbers.remove(2)       # Remove item (error if not found)
numbers.discard(10)     # Remove item (no error if not found)
numbers.clear()         # Remove all items

Use cases for sets

Remove duplicates: unique = set([1, 2, 2, 3, 3, 3]) → {1, 2, 3}
Check membership: Sets are faster than lists for in checks
Mathematical operations: Union, intersection, difference

Dictionaries — Key-Value Pairs

A dictionary stores pairs of keys and values. You access values using their keys, not positions.

Creating dictionaries

person = {
    "name": "Ramesh",
    "age": 25,
    "city": "Chennai"
}

scores = {"math": 95, "science": 87, "history": 92}
empty = {}

Use curly braces with key: value pairs. Keys are usually strings; values can be any type.

Accessing and modifying

person = {"name": "Ramesh", "age": 25}

print(person["name"])       # Ramesh
print(person["age"])        # 25

# Modify existing key
person["age"] = 26

# Add new key
person["city"] = "Chennai"

# Try to access non-existent key (safer way)
person.get("phone")         # None (no error)
person.get("phone", "N/A")  # N/A (default value)

Dictionary methods

person = {"name": "Ramesh", "age": 25, "city": "Chennai"}

# Get all keys, values, or pairs
print(person.keys())        # dict_keys(['name', 'age', 'city'])
print(person.values())      # dict_values(['Ramesh', 25, 'Chennai'])
print(person.items())       # dict_items([('name', 'Ramesh'), ('age', 25), ...])

# Iterate
for key in person:
    print(f"{key}: {person[key]}")

# Iterate over pairs
for key, value in person.items():
    print(f"{key}: {value}")

# Remove items
person.pop("age")           # Remove and return value
person.popitem()            # Remove last pair
person.clear()              # Remove all

# Update from another dict
person.update({"phone": "555-1234", "age": 26})

Nested dictionaries

Dictionaries can contain other dictionaries (or lists, or tuples):

team = {
    "player1": {"name": "Ramesh", "score": 95},
    "player2": {"name": "Priya", "score": 87},
    "player3": {"name": "Arun", "score": 92}
}

print(team["player1"]["name"])  # Ramesh
print(team["player2"]["score"]) # 87

Choosing the Right Collection

Collection	Ordered	Changeable	Duplicates	Use Case
List	✓	✓	✓	Store sequence of items
Tuple	✓	✗	✓	Immutable sequences, dict keys
Set	✗	✓	✗	Unique values, membership checks
Dict	✓ (Python 3.7+)	✓	✓ (values)	Store labeled data, key-value lookup

Practical Examples

Example 1: Managing a to-do list

todos = []

# Add tasks
todos.append("Buy groceries")
todos.append("Finish project")
todos.append("Call mom")

# Mark as done (remove)
todos.remove("Buy groceries")

# Show remaining
for i, task in enumerate(todos):
    print(f"{i+1}. {task}")

Output:

1. Finish project
2. Call mom

Example 2: Count word frequency

text = "the quick brown fox jumps over the lazy dog the fox"
words = text.split()
word_count = {}

for word in words:
    if word in word_count:
        word_count[word] += 1
    else:
        word_count[word] = 1

print(word_count)
# {'the': 3, 'quick': 1, 'brown': 1, 'fox': 2, ...}

Or more concisely:

from collections import Counter
word_count = Counter(words)
print(word_count)

Example 3: Find common interests

alice_interests = {"python", "music", "hiking", "gaming"}
bob_interests = {"python", "gaming", "cooking", "music"}

# What do they both enjoy?
common = alice_interests & bob_interests
print(common)  # {'python', 'gaming', 'music'}

# What does Alice enjoy that Bob doesn't?
alice_unique = alice_interests - bob_interests
print(alice_unique)  # {'hiking'}

Why This Matters

Collections are fundamental to every real program. You'll spend most of your programming time manipulating lists, dictionaries, and sets. Once you internalize which tool is right for each job, you'll write cleaner, faster code.

The most common beginner mistakes:

Confusing list and tuple syntax ([] vs ())
Trying to add items to a tuple (they're immutable!)
Using {} for an empty set and getting a dict instead
Trying to use lists as dictionary keys (they're unhashable)
Forgetting that dictionaries store by key, not position

What's Next

In Part 6, explored functions — how to write reusable blocks of code, pass data to them, and get results back. Functions combined with collections are incredibly powerful.

This is Part 5 of an 8-part beginner Python series. Catch up on Part 1: Getting Started & Syntax, Part 2: Variables, Data Types & Numbers, Part 3: Strings & Booleans, and Part 4: Operators & Control Flow.

Python for Beginners — Part 4: Operators & Control Flow

Ramesh S — Mon, 22 Jun 2026 17:38:46 +0000

Part 4 of a beginner-friendly series on learning Python from scratch.

In Part 3, we learned about booleans — values that are either True or False — and the comparison operators that produce them. Now it's time to put that logic to work.

This is where your programs start to come alive: making decisions, repeating tasks, and responding to different situations. Control flow is the backbone of every real program you'll ever write.

Decision-Making: If, Elif, Else

The most fundamental control flow tool is the if statement. It lets your program make a decision: if something is true, do this; otherwise, do that.

The if statement

age = 25

if age >= 18:
    print("You are an adult")

The syntax is simple:

Write if followed by a condition
End the line with a colon :
Indent the code block that follows (4 spaces)

Only if the condition is True does the indented code run. If it's False, the code is skipped.

age = 15

if age >= 18:
    print("You are an adult")

print("This always prints")  # This runs regardless of the condition

Here, the first print runs only if age >= 18. The second print always runs because it's not indented under the if.

The else clause

Often you want to do something different if the condition is false:

age = 15

if age >= 18:
    print("You are an adult")
else:
    print("You are a minor")

The else block runs when the if condition is False.

The elif clause — multiple conditions

For more than two paths, use elif (short for "else if"). You can chain as many as you need:

score = 85

if score >= 90:
    print("Grade: A")
elif score >= 80:
    print("Grade: B")
elif score >= 70:
    print("Grade: C")
elif score >= 60:
    print("Grade: D")
else:
    print("Grade: F")

Python evaluates each condition from top to bottom and stops at the first True one. So for score = 85:

Is 85 >= 90? No.
Is 85 >= 80? Yes → prints "Grade: B" and stops.
Everything after is skipped.

Important: Once one condition is True, the rest are not checked. If you have overlapping conditions, order them carefully.

Nested if statements

You can put if statements inside if statements:

age = 25
has_license = True

if age >= 18:
    if has_license:
        print("You can drive")
    else:
        print("You need a license first")
else:
    print("You must be 18 to drive")

This works, but too much nesting gets hard to read. Keep it shallow when possible.

Ternary Operator — Inline If

For simple, one-line decisions, Python has a compact syntax:

status = "adult" if age >= 18 else "minor"

This is equivalent to:

if age >= 18:
    status = "adult"
else:
    status = "minor"

Read it as: "Set status to 'adult' if age >= 18, else set it to 'minor'."

The Match Statement (Python 3.10+)

Python 3.10 introduced match, similar to switch in other languages. It's useful when you have one variable with many possible values:

day = "Monday"

match day:
    case "Monday":
        print("Start of the work week")
    case "Friday":
        print("Almost the weekend!")
    case "Saturday" | "Sunday":
        print("It's the weekend!")
    case _:
        print("Some other day")

The _ (underscore) acts like a default case — it matches anything not caught by previous cases.

Note: If you're using Python < 3.10, match won't work. Use if/elif/else instead. For now, this is nice-to-know, not essential.

Repeating Code: Loops

Loops let you run the same code multiple times without repeating it. There are two main types: while and for.

While loops — repeat until a condition is false

A while loop keeps running as long as its condition is True:

count = 1

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

Output:

This will print 1–5. Let's trace it:

Is count <= 5? (1 <= 5) Yes → print 1, then count becomes 2
Is count <= 5? (2 <= 5) Yes → print 2, then count becomes 3
... continues until count becomes 6
Is count <= 5? (6 <= 5) No → loop exits

⚠️ Infinite loops: If you forget to change the condition, your loop runs forever:

count = 1
while count <= 5:
    print(count)
    # Oops, forgot to increment count — this runs forever!

If this happens, press Ctrl+C in your terminal to stop it.

For loops — repeat a specific number of times

A for loop is perfect when you know exactly how many times you want to repeat something. The most common pattern is using range():

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

Output:

range(5) generates the numbers 0, 1, 2, 3, 4 (note: 5 is not included). You can customize this:

range(5)        # 0, 1, 2, 3, 4
range(1, 6)     # 1, 2, 3, 4, 5 (start at 1, stop before 6)
range(0, 10, 2) # 0, 2, 4, 6, 8 (start at 0, stop before 10, step by 2)
range(10, 0, -1) # 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 (count backward)

The variable i (or any name you choose) takes on each value from the range, one per loop iteration.

Iterating over strings and lists

for loops are also perfect for going through each character in a string or each item in a list:

word = "Python"

for letter in word:
    print(letter)

Output:

P
y
t
h
o
n

Or with a list:

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

for fruit in fruits:
    print(fruit)

Output:

apple
banana
cherry

We delved into lists in Part 5, but this pattern is so common you'll see it everywhere.

Break and Continue

Sometimes you want to exit a loop early or skip to the next iteration. break and continue let you do this.

Break — exit the loop immediately

count = 1

while count <= 10:
    if count == 5:
        break  # Exit the loop
    print(count)
    count = count + 1

print("Loop ended")

Output:

1
2
3
4
Loop ended

When count reaches 5, break exits the loop. Nothing after the break in that iteration runs.

Continue — skip to the next iteration

for i in range(1, 6):
    if i == 3:
        continue  # Skip this iteration
    print(i)

Output:

When i == 3, continue jumps to the next iteration of the loop. The print(3) is never reached, but the loop keeps going.

Practical Examples

Example 1: Guessing game

secret = 42
guess = 0

while guess != secret:
    guess = int(input("Guess the number: "))

    if guess < secret:
        print("Too low!")
    elif guess > secret:
        print("Too high!")
    else:
        print("You got it!")

This keeps asking for guesses until the user gets it right.

Example 2: Multiplication table

number = 7

for i in range(1, 11):
    print(f"{number} × {i} = {number * i}")

Output:

7 × 1 = 7
7 × 2 = 14
7 × 3 = 21
... (up to 7 × 10 = 70)

Example 3: Finding even numbers

for i in range(1, 21):
    if i % 2 == 0:
        print(i)

Output:

(i % 2 == 0 is True for even numbers)

Why This Matters

Control flow is what separates a calculator from a real program. Every decision your code makes, every task it repeats, every time it reacts to different input — that's control flow at work. Master if statements and loops now, and you'll be amazed how much you can build.

The most common beginner mistakes:

Forgetting the colon (:) after if, else, for, while
Forgetting to indent the code block
Using = (assignment) instead of == (comparison) in conditions
Getting stuck in infinite loops (remember: Ctrl+C)

Once you internalize these patterns, they become automatic.

What's Next

In Part 5, we explored collections — lists, tuples, sets, and dictionaries — Python's most powerful ways to store and organize data. You'll learn how to work with multiple values at once, which pairs perfectly with the loops you just mastered.

This is Part 4 of an 8-part beginner Python series. Catch up on Part 1: Getting Started & Syntax, Part 2: Variables, Data Types & Numbers, and Part 3: Strings & Booleans.

Python for Beginners — Part 3: Strings & Booleans

Ramesh S — Sat, 20 Jun 2026 03:50:48 +0000

Python for Beginners — Part 3: Strings & Booleans

Part 3 of a beginner-friendly series on learning Python from scratch.

In Part 2, we learned how variables hold data and how Python figures out types automatically. Now we're going to get comfortable with the two types you'll probably use more than any others: strings (text) and booleans (true/false logic).

What is a String?

A string is a sequence of characters — letters, numbers, spaces, punctuation — anything you can type. In Python, strings are wrapped in quotes (single or double):

name = "Ramesh"
greeting = 'Hello, World!'
address = "123 Main Street, Chennai"

Single and double quotes work identically — use whichever feels natural. The only rule is: start and end with the same type.

msg = "It's a beautiful day"    # fine — single quote inside double quotes
msg = 'It's a beautiful day'    # ERROR — the middle quote closes the string early
msg = 'It\'s a beautiful day'   # fine — backslash escapes the quote

Multi-line strings

For longer text, use triple quotes (three single or double quotes in a row):

poem = """
Roses are red,
Violets are blue,
Python is awesome,
And you can code too.
"""

This is also handy for comments spanning multiple lines.

String Operations

Concatenation — joining strings

Use + to join strings together:

first_name = "Ramesh"
last_name = "Kumar"
full_name = first_name + " " + last_name
print(full_name)  # Ramesh Kumar

Repetition — repeating strings

Use * to repeat a string a certain number of times:

print("Ha" * 3)    # HaHaHa
print("-" * 20)    # --------------------

String length

Use len() to count how many characters are in a string:

text = "Python"
print(len(text))   # 6

String Indexing & Slicing

Strings are sequences, which means each character has a position. Python uses zero-based indexing — the first character is at position 0.

word = "Python"
print(word[0])    # P
print(word[1])    # y
print(word[5])    # n
print(word[-1])   # n (the last character)
print(word[-2])   # o (second from the end)

Negative indices count backward from the end.

Slicing — extracting parts of a string

Use the slice syntax [start:end] to extract a substring. Remember: end is exclusive (not included):

word = "Python"
print(word[0:2])   # Py (positions 0 and 1, not 2)
print(word[2:6])   # thon (positions 2, 3, 4, 5)
print(word[:3])    # Pyt (from start up to position 3)
print(word[3:])    # hon (from position 3 to the end)
print(word[::2])   # Pto (every 2nd character)

If you're new to slicing, write out the positions on paper once or twice — it clicks quickly.

String Methods

Strings come with dozens of built-in methods — functions that operate on the string itself. Here are the ones you'll use constantly:

text = "hello world"

# Change case
print(text.upper())            # HELLO WORLD
print(text.capitalize())       # Hello world
print(text.title())            # Hello World

# Find and replace
print(text.find("world"))      # 6 (position where "world" starts)
print(text.replace("world", "Python"))  # hello Python

# Strip whitespace
messy = "  hello  "
print(messy.strip())           # hello (removes leading/trailing spaces)
print(messy.lstrip())          # hello   (removes from left only)
print(messy.rstrip())          #   hello (removes from right only)

# Check properties
print(text.startswith("hello"))     # True
print(text.endswith("world"))       # True
print(text.isdigit())              # False
print(text.isalpha())              # False (has a space)
print("123".isdigit())             # True

# Split and join
words = text.split()               # ["hello", "world"]
print(" ".join(words))             # hello world

Pro tip: When you type a variable name followed by a dot in most code editors, you'll get an autocomplete menu showing all available methods. This is invaluable — you don't need to memorize everything, just know they exist.

String Formatting

As your programs grow, you'll often need to insert variable values into strings. There are several ways to do this:

f-strings (Python 3.6+, recommended)

The modern, readable way:

name = "Ramesh"
age = 25
city = "Chennai"

message = f"My name is {name}, I'm {age} years old, and I live in {city}."
print(message)  # My name is Ramesh, I'm 25 years old, and I live in Chennai.

You can even do simple expressions inside the braces:

x = 10
y = 20
print(f"The sum of {x} and {y} is {x + y}.")  # The sum of 10 and 20 is 30.

.format() method (older, still valid)

message = "My name is {}, I'm {} years old.".format(name, age)
print(message)

String concatenation (not recommended for complex cases)

message = "My name is " + name + ", I'm " + str(age) + " years old."

This works, but gets messy fast. f-strings are cleaner and faster.

Booleans

A boolean is a value that's either True or False. It's the simplest data type in Python, but also one of the most important because booleans drive all the decision-making in your programs.

is_raining = True
is_sunny = False

Boolean values are returned by comparison operators — expressions that compare two values:

x = 10
y = 20

print(x == y)    # False (equal to)
print(x != y)    # True (not equal to)
print(x < y)     # True (less than)
print(x > y)     # False (greater than)
print(x <= y)    # True (less than or equal)
print(x >= y)    # False (greater than or equal)

You can also compare strings:

print("apple" == "apple")       # True
print("apple" < "banana")       # True (alphabetical order)
print("apple" != "banana")      # True

Logical Operators

With boolean values, you can combine multiple conditions using logical operators:

`and` — both must be True

age = 25
has_license = True

can_drive = (age >= 18) and (has_license == True)
print(can_drive)  # True

`or` — at least one must be True

is_weekend = True
is_holiday = False

no_work = is_weekend or is_holiday
print(no_work)  # True

`not` — reverses the boolean

is_raining = True
print(not is_raining)   # False
print(not False)        # True

These operators are essential for building if statements, which we'll cover in depth in Part 4.

Why This Matters

Strings and booleans are the workhorses of Python. Nearly every program you write will manipulate text (logs, user messages, file contents, API responses) and make decisions based on true/false logic. Getting comfortable with string slicing, methods, and formatting early will save you hours of debugging later. And understanding how boolean expressions work is the foundation for all the control flow we're about to cover.

What's Next

In Part 4, we explored operators and control flow — how to build if/elif/else statements, use while and for loops, and make your programs actually do things based on conditions.

This is Part 3 of an 8-part beginner Python series. Catch up on Part 1: Getting Started & Syntax and Part 2: Variables, Data Types & Numbers.

Python for Beginners — Part 2: Variables, Data Types & Numbers

Ramesh S — Sat, 20 Jun 2026 03:29:52 +0000

Part 2 of a beginner-friendly series on learning Python from scratch.

In Part 1, we installed Python, wrote our first program, and learned the syntax rules that hold everything together. Now it's time to start storing and working with information — which means variables and data types.

What is a Variable?

A variable is a name that points to a value stored in memory. Think of it as a labeled container you can put something into, and refer back to later by name.

name = "Ramesh"
age = 25

Unlike many other languages, Python doesn't need you to declare a variable's type ahead of time. You just assign a value with =, and Python figures out the type on its own. This is called dynamic typing.

x = 5        # x is an integer
x = "hello"  # now x is a string — totally legal in Python

This flexibility is convenient, but it also means you need to be a little more careful — Python won't stop you from changing a variable's type halfway through your program, even if that wasn't your intention.

Variable Naming Rules

Python is strict about how variable names can look:

Must start with a letter or an underscore (_) — never a number.
Can only contain letters, numbers, and underscores.
Cannot be a Python keyword (class, for, if, etc.).
Are case-sensitive — age, Age, and AGE are three different variables.

age = 25        # valid
_age = 25       # valid
age2 = 25       # valid
2age = 25       # invalid — cannot start with a number
my-age = 25     # invalid — hyphens aren't allowed

Naming conventions

Python's style guide (PEP 8) recommends snake_case for variable names — lowercase words separated by underscores:

first_name = "Ramesh"
total_score = 95

Assigning Multiple Variables

Python lets you assign several variables in a single line, which keeps code compact and readable.

# One value to multiple variables
x = y = z = 10

# Multiple values to multiple variables
name, age, city = "Ramesh", 25, "Chennai"

Data Types in Python

Every value in Python belongs to a data type, which determines what kind of operations you can perform on it. Here are the core built-in types you'll use constantly:

Type	Example	Description
`str`	`"hello"`	Text
`int`	`25`	Whole numbers
`float`	`3.14`	Decimal numbers
`bool`	`True` / `False`	Logical values
`list`	`[1, 2, 3]`	Ordered, changeable collection
`tuple`	`(1, 2, 3)`	Ordered, unchangeable collection
`dict`	`{"a": 1}`	Key-value pairs
`set`	`{1, 2, 3}`	Unordered, unique values
`NoneType`	`None`	Represents "no value"

We delved into collections (list, tuple, dict, set) in Part 5. For now, let's focus on the basics — strings, numbers, and booleans.

Checking a variable's type

Use the built-in type() function any time you want to confirm what you're working with:

x = 25
print(type(x))     # <class 'int'>

y = "hello"
print(type(y))     # <class 'str'>

This is one of the most useful debugging habits you can build early on.

Numbers in Python

Python has three numeric types you'll run into regularly:

int — whole numbers, positive or negative, with no limit on size: 10, -45, 1000000
float — numbers with a decimal point: 3.14, -0.5, 2.0
complex — numbers with an imaginary part, written with a j: 3 + 4j (rare for beginners, but good to know it exists)

x = 10        # int
y = 3.14      # float
z = 3 + 4j    # complex

print(type(x), type(y), type(z))

Basic arithmetic

Python supports all the math operations you'd expect:

a = 10
b = 3

print(a + b)   # 13  → addition
print(a - b)   # 7   → subtraction
print(a * b)   # 30  → multiplication
print(a / b)   # 3.333... → division (always returns a float)
print(a // b)  # 3   → floor division (drops the decimal)
print(a % b)   # 1   → modulus (remainder)
print(a ** b)  # 1000 → exponent (a to the power of b)

Note that / always returns a float, even if the result is a whole number:

print(10 / 2)   # 5.0, not 5

Type Casting

Sometimes you need to convert a value from one type to another — this is called casting. Python gives you simple functions for this:

x = "25"
y = int(x)      # converts string "25" to integer 25

a = 25
b = str(a)      # converts integer 25 to string "25"

c = "3.14"
d = float(c)    # converts string "3.14" to float 3.14

This comes up constantly in real programs — for example, when you take user input (which always arrives as a string) and need to do math with it:

user_input = input("Enter your age: ")  # this is a string, even if you type "25"
age = int(user_input)                   # now it's a usable integer
print(age + 5)

If you try to do math directly on the unconverted string, Python will raise a TypeError — so casting isn't optional here, it's required.

Why This Matters

Dynamic typing is one of the reasons Python feels fast to write in — you spend less time declaring types and more time solving the actual problem. But that same flexibility is also where beginners get tripped up: a variable that started as a number can quietly become a string somewhere in your code, and the bug only shows up when you try to do math on it. Getting comfortable with type() and casting early will save you a lot of confusion later.

What's Next

In Part 3, we covered strings and booleans — how to slice and format text, the most useful string methods, and how Python handles True/False logic.

This is Part 2 of an 8-part beginner Python series. Catch up on Part 1: Getting Started & Syntax.

Python for Beginners — Part 1: Getting Started & Syntax

Ramesh S — Sat, 20 Jun 2026 03:10:31 +0000

A beginner-friendly series on learning Python from scratch, one concept at a time.

If you've ever wanted to learn programming but felt intimidated by curly braces, semicolons, and confusing syntax — Python is where you start breathing easy. It reads almost like English, and it's one of the most in-demand languages in the world today, used everywhere from web apps to data science to automation scripts.

This is Part 1 of a beginner series that will take you from "what even is Python" to writing real, working programs. Let's begin.

What is Python?

Python is a general-purpose programming language created by Guido van Rossum and first released in 1991. It's popular because of three big reasons:

It's beginner-friendly. The syntax is clean and close to natural language.
It's versatile. You can build websites, automate tasks, analyze data, train machine learning models, or write small scripts — all with Python.
It has a massive ecosystem. Thousands of ready-made libraries mean you rarely build things from scratch.

Python runs on Windows, macOS, and Linux, and it's free and open source.

Installing Python

Most systems can run Python after a quick install:

Go to python.org/downloads and grab the latest stable version.
During installation on Windows, make sure to check "Add Python to PATH" — this saves you a lot of headaches later.
Verify the install by opening your terminal (Command Prompt, PowerShell, or your Mac/Linux terminal) and typing:

python --version

If you see something like Python 3.13.0, you're good to go.

Tip: On some systems (especially macOS/Linux), you might need to type python3 instead of python.

Your First Python Program

Open a terminal, type python, hit Enter, and you'll land inside the Python interactive shell. Try this:

print("Hello, World!")

You should see:

Hello, World!

Congratulations — you just wrote your first Python program. print() is a built-in function that displays output on the screen.

For anything beyond one-liners, you'll want to write code in a .py file instead of the shell. Create a file called hello.py:

print("Hello, World!")

Then run it from your terminal:

python hello.py

Python Syntax: The Basics

Python's syntax is what makes it stand out from languages like Java or C++. Here's what you need to know early on.

No semicolons, no curly braces

Most languages need ; to end a line and {} to define blocks of code. Python uses neither. Instead, it relies on line breaks and indentation.

print("This line ends with nothing special")

Indentation defines structure

This is the single most important rule in Python. Indentation (spaces at the start of a line) isn't just for readability — it's part of the language's syntax. It tells Python which lines belong together.

if 5 > 2:
    print("Five is greater than two!")

The line print("Five is greater than two!") is indented, which tells Python it belongs inside the if block. If you don't indent it, Python will throw an error:

if 5 > 2:
print("This will cause an IndentationError")

Rule of thumb: use 4 spaces per indentation level, and stay consistent. Most code editors do this automatically.

Case sensitivity

Python treats uppercase and lowercase letters as different. age, Age, and AGE are three separate variables.

One statement per line (usually)

Unlike some languages, you generally write one instruction per line in Python:

x = 5
y = 10
print(x + y)

You can squeeze multiple statements onto one line using a semicolon, but it's considered bad style and rarely used:

x = 5; y = 10; print(x + y)

Comments in Python

Comments are notes in your code that Python ignores when running the program. They're there purely for humans — to explain what the code does, leave reminders, or temporarily disable a line.

Single-line comments

Use a # symbol:

# This is a comment
print("Hello, World!")  # This prints a greeting

Anything after # on that line is ignored by Python.

Multi-line comments

Python doesn't have a dedicated multi-line comment symbol, but there are two common workarounds:

Option 1 — a # on every line:

# This is a comment
# written across
# multiple lines
print("Hello, World!")

Option 2 — a multi-line string that isn't assigned to anything:

"""
This is also
a comment,
technically a string Python evaluates and discards
"""
print("Hello, World!")

This second method isn't a "true" comment (it's a string literal Python briefly creates and throws away), but it's commonly used for quick documentation blocks.

Why This Matters

Indentation and clean syntax aren't just stylistic choices in Python — they're enforced by the language itself. This is intentional. Python's design philosophy ("The Zen of Python") leans heavily on readability: code should look the same regardless of who wrote it. Once this clicks, you'll find Python code far easier to read than most other languages, even months after you wrote it yourself.

What's Next

In Part 2, we covered variables, data types, and numbers — how Python stores information, the rules for naming variables, and how to work with different types of data.

This is Part 1 of a beginner Python series. Follow along for the rest of the series covering strings, control flow, functions, collections, error handling, and object-oriented programming.

Structuring TypeScript: Interfaces, Type Aliases, Enums, and Object Types

Ramesh S — Fri, 19 Jun 2026 03:27:06 +0000

Structuring TypeScript: Interfaces, Type Aliases, Enums, and Object Types

You've learned TypeScript's primitive types and the basics of type inference here. Now it's time to model real-world data — users, orders, API responses, configuration objects. That's where interfaces, type aliases, and enums come in.

These three features are what make TypeScript genuinely powerful for building applications. Let's dig in.

Object Types: Describing the Shape of Data

Before we get to interfaces, let's understand object types. When you want to describe the structure of an object, you define what properties it has and what types those properties are:

// Inline object type annotation
function displayUser(user: { name: string; age: number; email: string }): void {
  console.log(`${user.name} (${user.age}) — ${user.email}`);
}

This works, but it's messy to repeat everywhere. That's why we use type aliases and interfaces to name and reuse these shapes.

Type Aliases: Naming a Type

A type alias gives a name to any type — primitives, unions, objects, or combinations:

// Alias for a primitive union
type ID = string | number;

// Alias for an object shape
type User = {
  id: ID;
  name: string;
  age: number;
  email: string;
};

// Now use it anywhere
const user: User = {
  id: 1,
  name: "Ramesh",
  age: 31,
  email: "ramesh@example.com",
};

function getUser(id: ID): User {
  // ... fetch user logic
}

Type aliases are flexible — they can represent almost anything.

Interfaces: Defining Object Contracts

An interface is specifically designed to describe the shape of an object. Syntax is slightly different:

interface User {
  id: number;
  name: string;
  age: number;
  email: string;
}

const user: User = {
  id: 1,
  name: "Ramesh",
  age: 31,
  email: "ramesh@example.com",
};

Optional and Readonly Properties

Properties can be marked as optional (?) or read-only (readonly):

interface UserProfile {
  readonly id: number;      // Can't be changed after creation
  name: string;
  age?: number;             // Optional — may or may not be present
  bio?: string;             // Optional
}

const profile: UserProfile = { id: 101, name: "Ramesh" };
profile.id = 999;           // ❌ Error: Cannot assign to 'id' (readonly)
profile.age = 31;           // ✅ Fine, optional doesn't mean immutable

Extending Interfaces

Interfaces support inheritance — you can build on existing ones:

interface Animal {
  name: string;
  sound(): string;
}

interface Dog extends Animal {
  breed: string;
  fetch(): void;
}

const myDog: Dog = {
  name: "Bruno",
  breed: "Labrador",
  sound: () => "Woof!",
  fetch: () => console.log("Fetching..."),
};

This is great for modelling hierarchical data (e.g. AdminUser extends User).

`interface` vs `type`: When to Use Which

This is one of TypeScript's most debated questions. Here's a practical answer:

Feature	`interface`	`type`
Object shapes	✅	✅
Primitives/unions	❌	✅
Extending/inheriting	`extends` keyword	Intersection (`&`)
Declaration merging	✅	❌
Use with classes	✅ Preferred	Works

// Extending with interface
interface Animal { name: string; }
interface Dog extends Animal { breed: string; }

// Extending with type (using intersection)
type Animal = { name: string; };
type Dog = Animal & { breed: string; };

The honest answer:

Use interface for objects that represent real-world entities (users, products, components)
Use type for unions, intersections, utility combinations, and when you need to alias primitive types

In most modern TypeScript codebases, both work. Just be consistent within a project.

Enums: Named Constants That Make Sense

An enum is a set of named constant values. Instead of using magic strings or numbers scattered across your code, you define them once:

Numeric Enums

enum Direction {
  Up,    // 0
  Down,  // 1
  Left,  // 2
  Right, // 3
}

function move(dir: Direction): void {
  console.log(`Moving in direction: ${dir}`);
}

move(Direction.Up);    // ✅ Clean, readable
move(0);               // ✅ Also works (but less clear)
move("Up");            // ❌ Error

Values auto-increment from 0. You can override the starting number:

enum StatusCode {
  OK = 200,
  NotFound = 404,
  ServerError = 500,
}

console.log(StatusCode.OK); // 200

String Enums (More Common in Practice)

enum OrderStatus {
  Pending = "PENDING",
  Processing = "PROCESSING",
  Shipped = "SHIPPED",
  Delivered = "DELIVERED",
  Cancelled = "CANCELLED",
}

function updateOrderStatus(orderId: number, status: OrderStatus): void {
  console.log(`Order ${orderId} is now: ${status}`);
}

updateOrderStatus(1001, OrderStatus.Shipped);
// Output: Order 1001 is now: SHIPPED

String enums are preferred because the values are human-readable in logs, APIs, and debugging.

When to Use Enums vs Union Types

// Union type approach
type OrderStatus = "PENDING" | "SHIPPED" | "DELIVERED";

// Enum approach
enum OrderStatus {
  Pending = "PENDING",
  Shipped = "SHIPPED",
  Delivered = "DELIVERED",
}

Use union types when the values are simple and stable. Use enums when you need a named, reusable group of constants — especially when the values are used across many files.

Putting It All Together: A Real Example

Here's how interfaces, type aliases, and enums work together in a realistic scenario:

// Enum for user roles
enum UserRole {
  Admin = "ADMIN",
  Editor = "EDITOR",
  Viewer = "VIEWER",
}

// Base interface for all users
interface BaseUser {
  readonly id: number;
  name: string;
  email: string;
  createdAt: Date;
}

// Extended interface with role
interface AppUser extends BaseUser {
  role: UserRole;
  lastLogin?: Date;
}

// Type alias for API response shape
type ApiResponse<T> = {
  success: boolean;
  data: T;
  error?: string;
};

// Function using all of the above
function createUser(name: string, email: string, role: UserRole): ApiResponse<AppUser> {
  const newUser: AppUser = {
    id: Math.random(),
    name,
    email,
    role,
    createdAt: new Date(),
  };

  return {
    success: true,
    data: newUser,
  };
}

const result = createUser("Ramesh", "ramesh@example.com", UserRole.Admin);
console.log(result.data.role); // "ADMIN"

Notice how the types tell a clear story. You don't need to read the function implementation to understand what it takes and what it returns.

Common Mistakes to Avoid

Mistake 1: Over-nesting object types

// ❌ Hard to read and reuse
interface Order {
  user: {
    id: number;
    address: {
      street: string;
      city: string;
    };
  };
}

// ✅ Break it out into named types
interface Address {
  street: string;
  city: string;
}

interface OrderUser {
  id: number;
  address: Address;
}

interface Order {
  user: OrderUser;
}

Mistake 2: Numeric enums in APIs

// ❌ Numeric enum values in API responses are confusing
enum Status { Active, Inactive } // 0, 1 in JSON — meaningless without context

// ✅ String enums are self-documenting
enum Status { Active = "ACTIVE", Inactive = "INACTIVE" }

Summary

Here's what to remember from this post:

Object types describe the shape of an object inline
Type aliases (type) name any type — great for unions, intersections, and flexibility
Interfaces (interface) define object contracts — great for classes, extension, and real-world entities
Use readonly for immutable properties, ? for optional ones
Enums group related constants — prefer string enums for readability
Combine all three to model complex, real-world data clearly

You've completed the TypeScript Beginners Series. You now understand the full foundation: types, inference, arrays, tuples, unions, interfaces, aliases, and enums. That's everything you need to start writing real TypeScript confidently.

Found this helpful? Follow for the rest of the series. Questions or corrections? Drop them in the comments.

TypeScript Types Demystified: Simple Types, Special Types, and Type Inference

Ramesh S — Fri, 19 Jun 2026 03:22:28 +0000

TypeScript Types Demystified: Simple Types, Special Types, and Type Inference

In the first post, we covered why TypeScript exists and how to write your first program. Now it's time to get comfortable with the type system itself — the foundation everything else is built on.

By the end of this post, you'll know how to type variables, arrays, and function parameters correctly. You'll also understand the "special" types that trip up most beginners: any, unknown, never, and void.

The Core Primitive Types

TypeScript's basic types map directly to JavaScript's primitives:

// string
let firstName: string = "Ramesh";
let greeting: string = `Hello, ${firstName}`;

// number (no separate int/float — it's all number)
let age: number = 31;
let price: number = 9.99;
let hex: number = 0xFF;

// boolean
let isLoggedIn: boolean = true;
let hasAccess: boolean = false;

These are the types you'll use most often. Simple, predictable, and exactly what you'd expect.

Type Inference: TypeScript Does the Work

You don't always have to write the type. TypeScript infers it from the value you assign:

let city = "Chennai";    // TypeScript infers: string
let year = 2026;         // TypeScript infers: number
let isActive = true;     // TypeScript infers: boolean

Once inferred, that type is locked in:

let city = "Chennai";
city = 42; // ❌ Error: Type 'number' is not assignable to type 'string'

Rule of thumb: Let TypeScript infer types for local variables. Write explicit annotations for function parameters and return types.

// Let inference work for variables
const scores = [95, 87, 72]; // inferred as number[]

// Be explicit for function signatures
function calculateAverage(scores: number[]): number {
  return scores.reduce((a, b) => a + b, 0) / scores.length;
}

Explicit vs Inferred — When to Choose Each

// ✅ Explicit annotation — good for function params & return types
function formatName(first: string, last: string): string {
  return `${first} ${last}`;
}

// ✅ Inferred — good for simple variable assignments
const result = formatName("Ramesh", "Kumar"); // inferred as string

// ❌ Over-annotating — redundant when value makes it obvious
const count: number = 5; // The `= 5` already tells TypeScript it's a number

Arrays and Tuples

Arrays hold multiple values of the same type:

// Two equivalent syntaxes
let tags: string[] = ["typescript", "javascript", "react"];
let scores: Array<number> = [95, 87, 72];

// TypeScript will catch wrong types in arrays
tags.push(42); // ❌ Error: Argument of type 'number' is not assignable to type 'string'

Tuples are fixed-length arrays where each position has a specific type:

// A tuple: exactly [string, number]
let user: [string, number] = ["Ramesh", 31];

// Order and types are both enforced
let wrongOrder: [string, number] = [31, "Ramesh"]; // ❌ Error

// Accessing tuple elements
console.log(user[0]); // "Ramesh" — TypeScript knows this is string
console.log(user[1]); // 31 — TypeScript knows this is number

Tuples are great for things like coordinate pairs, key-value pairs, or when returning multiple values from a function:

function getMinMax(numbers: number[]): [number, number] {
  return [Math.min(...numbers), Math.max(...numbers)];
}

const [min, max] = getMinMax([3, 1, 7, 2, 9]);
// min: number, max: number — fully typed!

Union Types: When a Value Can Be Multiple Types

Sometimes a value can legitimately be more than one type. That's what union types handle:

// This function accepts string OR number
function formatId(id: string | number): string {
  return `ID-${id}`;
}

formatId("abc123"); // ✅
formatId(42);       // ✅
formatId(true);     // ❌ Error: boolean not in the union

Union types are especially useful for API responses, form inputs, and optional values:

// A status that can only be one of these three strings
let orderStatus: "pending" | "shipped" | "delivered";

orderStatus = "shipped";   // ✅
orderStatus = "cancelled"; // ❌ Error: not in the union

// A value that might not exist yet
let userId: number | null = null;
userId = 101; // Fine, it's assigned now

Special Types: `any`, `unknown`, `never`, `void`

These four confuse most beginners. Here's each one explained clearly.

`any` — The Escape Hatch (Use Sparingly)

any turns off TypeScript's type checking for that value:

let data: any = "hello";
data = 42;        // Fine
data = true;      // Fine
data.foo.bar();   // Fine — no error, even if this blows up at runtime!

When to use it: Almost never. any defeats the purpose of TypeScript. It's there as a last resort when migrating old JavaScript code.

// ❌ Overusing any — you've lost all type safety
function processData(input: any): any { ... }

// ✅ Be specific whenever possible
function processData(input: string[]): number { ... }

`unknown` — The Safe Version of `any`

unknown says "this could be anything, but I need to check before I use it":

let userInput: unknown = getUserInput();

// ❌ Can't use unknown directly
console.log(userInput.toUpperCase()); // Error!

// ✅ Must narrow the type first
if (typeof userInput === "string") {
  console.log(userInput.toUpperCase()); // Now it's safe
}

Prefer unknown over any when you genuinely don't know the type. It forces you to handle the uncertainty explicitly.

`void` — Functions That Return Nothing

Use void when a function doesn't return a value:

function logMessage(message: string): void {
  console.log(message);
  // No return statement needed
}

// Trying to use the return value of a void function makes no sense
const result = logMessage("hello"); // result is void — useless

`never` — Code That Never Completes

never represents values that never occur. It's used for:

Functions that always throw an error
Functions with infinite loops
Exhaustive type checking

// Always throws — never returns
function throwError(message: string): never {
  throw new Error(message);
}

// Exhaustive check — if you add a new status and forget to handle it,
// TypeScript will error here
function handleStatus(status: "active" | "inactive"): string {
  if (status === "active") return "User is active";
  if (status === "inactive") return "User is inactive";

  // This line should be unreachable
  const _exhaustive: never = status; // ❌ Error if you missed a case
  return _exhaustive;
}

never is an advanced concept — don't worry if it doesn't fully click yet. You'll encounter it naturally as you write more TypeScript.

Quick Reference: All the Types We Covered

// Primitives
let name: string = "Ramesh";
let age: number = 31;
let active: boolean = true;

// Arrays
let tags: string[] = ["ts", "js"];
let ids: number[] = [1, 2, 3];

// Tuples
let point: [number, number] = [10, 20];

// Union
let id: string | number = "abc";
let status: "on" | "off" = "on";

// Special types
let anything: any = "...";     // Avoid when possible
let safeAny: unknown = "...";  // Safer — must narrow before use
function log(): void { ... }   // No return value
function fail(): never { throw new Error(); } // Never returns

Wrapping Up

The TypeScript type system is deep, but the everyday usage is straightforward. Here's what to take away:

Primitives — string, number, boolean cover most cases
Type inference — TypeScript is smart; you don't need to annotate everything
Arrays — string[] or Array<string>, your choice
Tuples — fixed-length, fixed-type arrays
Union types — when a value can be more than one type
any — avoid it; unknown — use this instead when you must
void — functions with no return; never — functions that never return normally

Found this helpful? Follow for the rest of the series. Questions or corrections? Drop them in the comments.

TypeScript Explained: Why Every JavaScript Developer Should Care

Ramesh S — Fri, 19 Jun 2026 03:19:10 +0000

TypeScript Explained: Why Every JavaScript Developer Should Care

You've been writing JavaScript for years. It works. So why bother with TypeScript?

That's what I thought too — until I spent two days debugging a production bug that turned out to be a simple typo in a property name. A bug TypeScript would have caught in milliseconds.

In this post, I'll explain what TypeScript is, why it exists, and how to write your very first TypeScript program. No fluff — just what you actually need to know.

What Is TypeScript?

TypeScript is JavaScript with types added on top. That's really it.

It was created by Microsoft in 2012 and has since become one of the most popular tools in the JavaScript ecosystem — used by teams at Google, Airbnb, Slack, and countless others.

Here's the key thing to understand: TypeScript is not a replacement for JavaScript. It compiles down to plain JavaScript. Every browser, Node.js server, and JavaScript runtime runs the same JS it always has. TypeScript just helps you write better code before that happens.

JavaScript vs TypeScript — A Side-by-Side Look

Let's say you're writing a function to greet a user:

JavaScript:

function greetUser(name) {
  return "Hello, " + name.toUpperCase();
}

greetUser(42); // Runtime error: name.toUpperCase is not a function

You won't discover this mistake until the code runs — possibly in production, in front of real users.

TypeScript:

function greetUser(name: string): string {
  return "Hello, " + name.toUpperCase();
}

greetUser(42); // ❌ Error: Argument of type 'number' is not assignable to parameter of type 'string'

TypeScript catches this immediately in your editor — before you even run the code. That : string annotation tells TypeScript exactly what type name should be.

Why Use TypeScript? The Real Benefits

1. Catch Bugs Early

The most obvious benefit. Instead of runtime errors that crash your app, TypeScript surfaces type errors at compile time — while you're still writing code.

2. Better Autocomplete and IntelliSense

When TypeScript knows the shape of your data, your editor can suggest properties and methods automatically. This speeds up development significantly, especially in large codebases.

type User = {
  id: number;
  name: string;
  email: string;
};

const user: User = { id: 1, name: "Ramesh", email: "r@example.com" };

user. // ← your editor will instantly suggest: id, name, email

3. Self-Documenting Code

Types are living documentation. When you read a function signature like this:

function createOrder(userId: number, items: string[], total: number): Order

You immediately know what it expects and what it returns — no need to dig through docs or source code.

4. Safer Refactoring

Rename a property? Change a function signature? TypeScript will flag every place in your codebase that needs updating. In large apps, this is a game-changer.

Getting Started: Installation

You need Node.js installed. Then run:

npm install -g typescript

Verify the installation:

tsc --version
# Output: Version 5.x.x

What is tsc? It's the TypeScript Compiler — the tool that translates your .ts files into plain .js files.

Your First TypeScript Program

Create a new file called hello.ts:

// hello.ts

const message: string = "Hello, TypeScript!";
console.log(message);

function add(a: number, b: number): number {
  return a + b;
}

console.log(add(5, 10)); // 15
console.log(add(5, "10")); // ❌ TypeScript Error — caught before running!

Now compile it:

tsc hello.ts

This generates a hello.js file:

// hello.js (auto-generated)
var message = "Hello, TypeScript!";
console.log(message);

function add(a, b) {
  return a + b;
}

console.log(add(5, 10));

Notice what happened: the type annotations are gone in the output. They only exist to help you during development. The browser or Node.js never sees them.

Run the output:

node hello.js
# Hello, TypeScript!
# 15

Understanding Type Annotations

TypeScript's type annotation syntax uses a colon followed by the type name:

// Variables
let age: number = 30;
let username: string = "Ramesh";
let isActive: boolean = true;

// Functions
function multiply(x: number, y: number): number {
  return x * y;
}

// Arrays
let scores: number[] = [95, 87, 72];
let tags: string[] = ["typescript", "javascript", "webdev"];

You don't always have to write the type explicitly. TypeScript is smart enough to infer it:

let city = "Chennai"; // TypeScript infers: string
let year = 2026;      // TypeScript infers: number

This means you get type safety without having to annotate everything.

TypeScript vs JavaScript — Quick Comparison

Feature	JavaScript	TypeScript
Types	Dynamic (runtime)	Static (compile time)
Error detection	Runtime	Compile time
IDE support	Basic	Excellent (autocomplete, refactoring)
Learning curve	Low	Slightly higher
File extension	`.js`	`.ts`
Runs in browser	Directly	After compilation
Backwards compatible	—	Yes (compiles to JS)

Common Beginner Mistakes

Mistake 1: Using any everywhere

// ❌ This defeats the purpose of TypeScript
let data: any = fetchUser();

// ✅ Be specific
let data: User = fetchUser();

Mistake 2: Ignoring compiler errors

TypeScript errors are there to help you. Don't silence them with // @ts-ignore until you understand why they're happening.

Mistake 3: Thinking you need to annotate everything

Type inference handles a lot. Annotate function parameters and return types — TypeScript will figure out the rest.

Wrapping Up

Here's what you learned in this post:

TypeScript is JavaScript with optional static typing
It catches type errors at compile time, not runtime
Types make your code self-documenting and easier to refactor
Installing TypeScript takes 30 seconds with npm
Type annotations use the : type syntax, but inference means you don't need them everywhere

TypeScript has a small learning curve upfront, but it pays back many times over — especially as your codebase grows.

Found this helpful? Follow for the rest of the series. Questions or corrections? Drop them in the comments.

DEV Community: Ramesh S

Python for Beginners — Part 8: Object-Oriented Python

Classes and Objects

Defining a class

The __init__ Method and self

Creating multiple objects

Methods

Instance vs Class Variables

Inheritance

Using super()

Polymorphism

Encapsulation

Dunder Methods

__str__ and __repr__

__len__

__eq__

Properties and Getters/Setters

Practical Examples

Example 1: User class

Example 2: Inheritance with Bank Accounts

Example 3: Polymorphism with shapes

Why This Matters

Your Journey is Complete

What's Next

Python for Beginners — Part 7: Modules, Errors & Files

Modules and Imports

Using the math module

Importing specific items

Aliasing imports

Working with datetime

Working with JSON

Regular Expressions (Regex)

File Input and Output

Reading files

Writing files

Working with file paths

Exception Handling

Multiple exceptions

Try, except, else, finally

Raising exceptions

Installing External Libraries with pip

Practical Examples

Example 1: Read and count words

Example 2: Save and load JSON data

Example 3: Extract data with regex

Why This Matters

What's Next

Python for Beginners — Part 6: Functions

Defining and Calling Functions

The basics

Functions with parameters

Return values

Arguments: Positional vs Keyword

Positional arguments

Keyword arguments

Default Arguments

*args — Variable Number of Arguments

**kwargs — Keyword Arguments as Dictionary

Combining everything

Scope and Variable Lifetime

Local scope

Global scope

Modifying global variables

Lambda Functions — Quick Throwaway Functions

Recursion — Functions Calling Themselves

Classic example: Factorial

Generators and Iterators

Practical Examples

Example 1: Simple calculator

Example 2: Processing collections

Example 3: Flexible greeting

Why This Matters

What's Next

Python for Beginners — Part 5: Collections

Lists — Ordered, Changeable Collections

Creating and accessing lists

Slicing lists

Essential list methods

Modifying list items

Iterating over lists

The `init` Method and `self`

Using `super()`

`str` and `repr`

`len`

`eq`

`and` — both must be True

`or` — at least one must be True

`not` — reverses the boolean