codeaddict 님의 블로그

Python Intermediate_016_Encapsulation in Python — Concepts, Examples, and Practical Application

codeaddict — Sat, 5 Apr 2025 21:36:28 +0900

1. Introduction

Encapsulation is a cornerstone of object-oriented programming (OOP) that bundles data (attributes) and the methods that manipulate it into a single unit — a class — while restricting direct access to the data.

Think of encapsulation as a secure vault. Inside the vault, you store sensitive items (data) and provide specific tools (methods) to interact with them. Only authorized personnel (the class’s methods) can access or modify the contents, while outsiders (external code) must use the provided interface.

In Python, encapsulation uses naming conventions:

Public: No prefix, accessible everywhere (e.g., data).
Protected: Single underscore (_data), a hint for internal or subclass use, though not enforced.
Private: Double underscore (__data), triggering name mangling to discourage direct access.

2. Encapsulation in Python: Public, Protected, and Private

Example 1: Public Members — Weather Data

class WeatherStation:
    def __init__(self, temperature):
        self.temp = temperature  # Public attribute

    def report(self):
        print(f"Current temperature: {self.temp}°C")

# Using the class
station = WeatherStation(25)
print(station.temp)  # Direct access
station.temp = -500  # Oops, unrealistic value
print(station.temp)
station.report()

Output:

25
-500
Current temperature: -500°C

Detailed Explanation:

temp is public, so anyone can read or write it (station.temp = -500).
Pros: Simple and straightforward for small, safe scenarios.
Cons: No validation means temp can be set to absurd values (e.g., -500°C), breaking the realism of a weather system.

Example 2: Protected Members — Inventory Tracker

class Inventory:
    def __init__(self, stock):
        self._stock = stock  # Protected attribute

    def check_stock(self):
        print(f"Items in stock: {self._stock}")

    def restock(self, amount):
        self._stock += amount
        print(f"Restocked {amount}. New stock: {self._stock}")

# Using the class
shop = Inventory(100)
print(shop._stock)  # Accessible, but discouraged
shop._stock = -10  # Can still modify, though it’s "protected"
print(shop._stock)
shop.check_stock()
shop.restock(50)

Output:

100
-10
Items in stock: -10
Restocked 50. New stock: 40

Detailed Explanation:

_stock with a single underscore is “protected,” signaling it’s for internal use or subclasses.
Python doesn’t block access (shop._stock = -10 works), but the underscore tells developers, “Hey, use the methods instead!”
Pros: Suggests a boundary, useful for teamwork or documentation.
Cons: No real protection — negative stock is still possible, which doesn’t make sense for an inventory.

Example 3: Private Members — Patient Records

class PatientRecord:
    def __init__(self, name, age):
        self.__name = name  # Private attribute
        self.__age = None   # Private attribute
        self.set_age(age)   # Use setter for validation

    def get_name(self):
        return self.__name

    def get_age(self):
        return self.__age

    def set_age(self, new_age):
        if isinstance(new_age, int) and 0 <= new_age <= 120:
            self.__age = new_age
        else:
            print(f"Error: Age must be an integer between 0 and 120. Keeping {self.__age}")

    def display(self):
        print(f"Patient: {self.__name}, Age: {self.__age}")

# Using the class
patient = PatientRecord("Emma", 30)
print(patient.get_name())  # Access via getter
patient.set_age(35)       # Update via setter
patient.display()
patient.set_age(-5)       # Invalid age
# print(patient.__age)     # AttributeError
patient.display()

Output:

Emma
Patient: Emma, Age: 35
Error: Age must be an integer between 0 and 120. Keeping 35
Patient: Emma, Age: 35

Detailed Explanation:

__name and __age are private,, making direct access tricky (patient.__age fails).
get_name, get_age, and set_age provide a controlled interface. set_age validates input, ensuring age stays realistic (0–120).
Pros: Protects sensitive data (like patient info) and enforces rules.

3. Why Encapsulation Matters: A Problem and Solution

Let’s apply encapsulation to a real-world data problem.

Problem: Managing a Budget Tracker

You’re creating a Budget class to track expenses. Without encapsulation, users could set the budget to negative values or bypass spending limits, breaking financial logic.

class Budget:
    def __init__(self, total):
        self.total = total  # Public attribute

    def spend(self, amount):
        self.total -= amount
        print(f"Spent {amount}. Remaining: {self.total}")

# Using the class
budget = Budget(1000)
print(f"Initial budget: {budget.total}")
budget.spend(300)
budget.total = -500  # Direct manipulation!
print(f"After tampering: {budget.total}")

Output:

Initial budget: 1000
Spent 300. Remaining: 700
After tampering: -500

Issue:

total is public, so it can be set to invalid values (e.g., -500), which doesn’t make sense for a budget.

Solution: Encapsulation with Private Members

class Budget:
    def __init__(self, total):
        self.__total = None  # Private attribute
        self.set_total(total)  # Validate initial value

    def get_total(self):
        return self.__total

    def set_total(self, amount):
        if isinstance(amount, (int, float)) and amount >= 0:
            self.__total = amount
        else:
            print(f"Error: Budget must be non-negative. Keeping {self.__total}")

    def spend(self, amount):
        if amount > 0 and amount <= self.__total:
            self.__total -= amount
            print(f"Spent {amount}. Remaining: {self.__total}")
        else:
            print(f"Error: Invalid spend amount or insufficient funds")

# Using the class
budget = Budget(1000)
print(f"Initial budget: {budget.get_total()}")
budget.spend(300)
budget.set_total(-500)  # Invalid attempt
# budget.__total = 2000   # AttributeError
budget.spend(200)
print(f"Final budget: {budget.get_total()}")

Output:

Initial budget: 1000
Spent 300. Remaining: 700
Error: Budget must be non-negative. Keeping 700
Spent 200. Remaining: 500
Final budget: 500

Explanation of the Solution:

__total is private, preventing direct changes (budget.__total = 2000 fails).
set_total ensures the budget stays non-negative, and spend checks for valid withdrawals.
get_total provides read-only access, keeping the interface clean.
Benefit: The budget stays logical and secure, avoiding negative or inconsistent states.

Python Intermediate_015_ Sorting with .sort() and Lambda in Python

codeaddict — Sat, 5 Apr 2025 21:34:47 +0900

Sorting is a fundamental operation in programming, and Python provides the .sort() method to make it easy to sort lists in place. When combined with the key parameter and lambda functions, .sort() becomes a powerful tool for custom sorting. In this tutorial, we’ll explore the traditional approach to sorting, introduce the .sort() method with lambda, and provide examples to solidify your understanding.

What is .sort() with Lambda?

The .sort() method modifies a list in place, arranging its elements in a specified order (ascending by default). The key parameter allows you to define a custom sorting criterion, and a lambda function provides a concise way to specify that criterion without defining a separate function.

Syntax:

list.sort(key=lambda x: expression)

.sort(): Sorts the list in place.
key=: Specifies the sorting rule.
lambda x: expression: An anonymous function where x is each list element, and expression defines what to sort by.

Examples of Sorting with .sort() and Lambda

Example 1: Sorting a List of Strings Alphabetically

Using a basic .sort():

fruits = ["banana", "apple", "cherry"]
fruits.sort()  # Default alphabetical sort
print(fruits)
# Output: ['apple', 'banana', 'cherry']

Using .sort() with lambda:

fruits = ["banana", "apple", "cherry"]
fruits.sort(key=lambda x: x[0])  # Sort by the first character
print(fruits)
# Output: ['apple', 'banana', 'cherry']

In this case, sorting by the first character (x[0]) gives the same result as the default sort, but it demonstrates how lambda works.

Example 2: Sorting a List of Tuples by the Second Element

Using a for loop (traditional approach):

fruits = [("banana", 3), ("apple", 2), ("cherry", 5)]
sorted_fruits = sorted(fruits, key=lambda x: x[1])  # Note: sorted() creates a new list
print(sorted_fruits)
# Output: [('apple', 2), ('banana', 3), ('cherry', 5)]

Using .sort() with lambda:

fruits = [("banana", 3), ("apple", 2), ("cherry", 5)] fruits.sort(key=lambda x: x[1]) # Sort by the second element (number) print(fruits) # Output: [('apple', 2), ('banana', 3), ('cherry', 5)]

Here, .sort() modifies the original list, sorting by the second element of each tuple (x[1]).

Example 3: Sorting Strings by Length

Using a basic .sort():

words = ["cat", "elephant", "dog"]
words.sort()  # Default alphabetical sort
print(words)
# Output: ['cat', 'dog', 'elephant']

Using .sort() with lambda:

words = ["cat", "elephant", "dog"]
words.sort(key=lambda x: len(x))  # Sort by string length
print(words)
# Output: ['cat', 'dog', 'elephant']

The lambda function len(x) sorts the list based on the length of each string.

Example 4: Sorting a List of Tuples by Multiple Criteria

Using .sort() with lambda:

items = [("apple", 2), ("banana", 1), ("apple", 1)]
items.sort(key=lambda x: (x[0], x[1]))  # Sort by fruit name, then number
print(items)
# Output: [('apple', 1), ('apple', 2), ('banana', 1)]

Here, the lambda returns a tuple (x[0], x[1]), sorting first by the fruit name and then by the number when names are identical.

Example 5: Sorting in Descending Order

Using .sort() with lambda and reverse:

numbers = [3, 1, 4, 1, 5]
numbers.sort(key=lambda x: x, reverse=True)  # Sort in descending order
print(numbers)
# Output: [5, 4, 3, 1, 1]

The reverse=True parameter flips the sort order, and the lambda x: x sorts based on the elements themselves.

When to Use .sort() with Lambda

Use .sort() with lambda when:

You need to sort a list in place based on a custom criterion.
You want concise, readable code for simple sorting logic.
The list contains complex elements like tuples or objects.

Do not use .sort() with lambda when:

You need a new sorted list without modifying the original (use sorted() instead).
The sorting logic is too complex for a single lambda expression.

Python Intermediate_014: Understanding @staticmethod in Python

codeaddict — Sat, 5 Apr 2025 21:33:43 +0900

In the previous lesson, we covered @classmethod.

In this tutorial, we will focus on @staticmethod and understand its role in Python. Static methods do not operate on an instance or the class itself, making them useful for utility functions that logically belong to a class but do not need access to instance or class attributes.

1. Regular Methods: Attached to the Class

Regular methods are glued to the class or its instances. Check this out:

class Car:
    def __init__(self, model):
        self.model = model

    def describe(self):  # Regular method
        return f"This is a {self.model}"

# Using it
my_car = Car("Toyota")
description = my_car.describe()  # This is a Toyota

Flow and Connection:

describe needs self — it’s attached to the instance (my_car). It grabs self.model to build the string.
Without an instance, this doesn’t work — you can’t call Car.describe() directly. It’s tied to the object’s state.

2. Static Methods vs. Standalone Functions

Now, let’s meet @staticmethod. It lives in the class but doesn’t need its data. To prove it’s not truly “attached,” I’ll pair it with an identical standalone function:

# Standalone function
def honk_sound():
    return "Beep beep!"

class Car:
    def __init__(self, model):
        self.model = model

    def describe(self):
        return f"This is a {self.model}"

    @staticmethod
    def honk_sound():  # Static method
        return "Beep beep!"

# Using both
standalone_result = honk_sound()      # Beep beep!
static_result = Car.honk_sound()      # Beep beep!
car_instance = Car("Toyota")
instance_result = car_instance.honk_sound()  # Beep beep!

Flow and Comparison:

Standalone honk_sound: A plain function, not tied to any class. Call it anywhere with honk_sound(), and it returns “Beep beep!” — no Car needed.
Static honk_sound: Lives inside Car, called with Car.honk_sound() or even car_instance.honk_sound(). It still returns “Beep beep!” but doesn’t use self or any Car data.
Key Point: Both do the exact same thing. The static version isn’t attached to the class’s state — it’s just parked there. The Car. prefix is Python’s way of organizing it, not a sign of dependency.

3. Practical Example: Numbers, No Class Strings Attached

Let’s try a number-based example. Regular methods use class data; static methods and standalone functions don’t:

# Standalone function
def square(n):
    return n * n

class NumberCruncher:
    def __init__(self, offset):
        self.offset = offset

    def add_offset(self, x):  # Regular method
        return x + self.offset

    @staticmethod
    def square(n):  # Static method
        return n * n

# Using them
cruncher = NumberCruncher(3)
offset_result = cruncher.add_offset(5)  # 8 (5 + 3)
static_result = NumberCruncher.square(4)  # 16 (4 * 4)
standalone_result = square(4)  # 16 (4 * 4)

Flow and Comparison:

add_offset: Needs self.offset (3), so it’s attached — adds 3 to 5, giving 8.
square (static): Takes n (4), returns 4 * 4 = 16. No self, no class data — just pure math.
square (standalone): Same as the static version, called without a class. Both are identical in behavior.
Difference: add_offset relies on the instance’s offset, while both squares are free of NumberCruncher’s state.

4. Another example

Here’s a practical case — cleaning text. Watch how the static method mirrors a standalone function:

# Standalone function
def strip_spaces(text):
    return text.replace(" ", "")

class TextCleaner:
    def __init__(self, signature):
        self.signature = signature

    def sign(self, text):  # Regular method
        return f"{text} - {self.signature}"

    @staticmethod
    def strip_spaces(text):  # Static method
        return text.replace(" ", "")

# Using them
cleaner = TextCleaner("ByMe")
signed = cleaner.sign("Hello World")      # Hello World - ByMe
static_clean = TextCleaner.strip_spaces("Hi There")  # HiThere
standalone_clean = strip_spaces("Hi There")  # HiThere

Flow and Comparison:

sign: Uses self.signature to append “ByMe” — it’s attached to the instance.
strip_spaces (static): Takes text, removes spaces, returns “HiThere”. No self, no class connection.
strip_spaces (standalone): Does the same, called directly. Both are interchangeable.
Difference: sign needs the instance’s signature, while strip_spaces doesn’t care about TextCleaner.

5. So, Why @staticmethod?

Regular Methods: Attached — use them when you need instance data (self) or class data (via @classmethod with cls).
Static Methods: Not attached — use them for utilities that don’t need class state. They’re like standalone functions, just stored in the class for organization.

Why ClassName.method() Then? Python sticks static methods in the class’s namespace. You could write them as standalone functions, but grouping them (e.g., TextCleaner.strip_spaces) keeps your code tidy and related tools together.

Python Intermediate_013: Understanding @classmethod in Python

codeaddict — Sat, 5 Apr 2025 21:32:33 +0900

In this lesson, we’ll learn about @classmethod . The @classmethod decorator is a neat feature in Python that lets you define methods tied to a class itself, not just its instances.

if you don’t know decorators yet, I have a lesson in Python Intermediate_006: Decorators in Python (https://medium.com/@staytechrich/python-intermediate-006-decorators-in-python-c7c7aaac7c8b) that’ll help you out. Let’s get started with some easy examples!

1. Basic @classmethod Example

Here’s a simple class method that greets you from the class level, not an instance:

class Greeter:
    message = "Hello from the class!"

    @classmethod
    def say_hello(cls):
        print("1. Inside class method: Accessing class data")
        return cls.message

print("START")
result = Greeter.say_hello()
print(f"RESULT: {result}")
print("END")

Output:

START
1. Inside class method: Accessing class data
RESULT: Hello from the class!
END

Order of Execution

Let’s break it down step-by-step:

@classmethod — Marks say_hello as a class method, passing cls (the class) instead of self.
print(“START”) — Prints “START” before the call.
result = Greeter.say_hello() — Calls the class method directly on Greeter.
print(“1. Inside class method…”) — Runs inside say_hello, showing it’s active.
return cls.message — Returns the class variable message (“Hello from the class!”).
print(f”RESULT: {result}”) — Prints the returned value.
print(“END”) — Prints “END”.

This is like a decorator wrapping a function, but here it shifts the focus to the class itself!

2. Practical Example: Instance Tracker

Now, let’s get practical. Imagine a class that tracks how many instances it’s created — perfect for debugging or stats. We’ll use @classmethod to report it.

class InstanceTracker:
    count = 0

    def __init__(self):
        InstanceTracker.count += 1  # Bump count when an instance is made

    @classmethod
    def get_count(cls):
        print("1. Inside class method: Checking instance count")
        return f"Total instances: {cls.count}"

# Test it
print("START")
t1 = InstanceTracker()
t2 = InstanceTracker()
result = InstanceTracker.get_count()
print(f"RESULT: {result}")
print("END")

Output:

START
1. Inside class method: Checking instance count
RESULT: Total instances: 2
END

Order of Execution (for the full test)

print(“START”) — Prints “START” before anything happens.
t1 = InstanceTracker() — Creates the first instance, __init__ runs, count becomes 1.
t2 = InstanceTracker() — Creates the second instance, count becomes 2.
result = InstanceTracker.get_count() — Calls the class method.
print(“1. Inside class method…”) — Runs inside get_count, showing it’s working.
return f”Total instances: {cls.count}” — Returns “Total instances: 2” using cls.count.
print(f”RESULT: {result}”) — Prints the result.
print(“END”) — Prints “END”.

For an instance call (e.g., t1.get_count()), it works the same way — cls still refers to InstanceTracker!

3. Why @classmethod Rocks

Class-Level Power: Access shared data (like count) without needing an instance.
Factory Vibes: Use it for alternative constructors (more on that below).

Bonus Example: Factory Method

Here’s a quick factory method using @classmethod, like a mini-decorator trick:

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

    @classmethod
    def from_string(cls, data):
        print("1. Inside class method: Parsing string")
        name, age = data.split("-")
        return cls(name, int(age))

print("START")
p = Person.from_string("Alice-30")
print(f"RESULT: {p.name}, {p.age}")
print("END")

Output:

START
1. Inside class method: Parsing string
RESULT: Alice, 30
END

Explanation Step by Step

1. What’s Happening When You Call Person.from_string(“Alice-30”)?

Normally, to make a Person object, you’d write something like person1 = Person(“Alice”, 30). This calls the class directly with two arguments (name and age).
But here, we’re using Person.from_string(“Alice-30”). This calls the @classmethod from_string instead of making the object right away. It’s a different way to create a Person.

2. Inside from_string(cls, data)

The @classmethod decorator changes how this method works. Instead of getting self (which is for instances), it gets cls, which stands for the class itself — in this case, Person.
data is the input you give when you call it. Here, data is the string “Alice-30”.
The method’s job is to take that string, break it apart, and use it to make a Person object.

3. What data Does in from_string

Inside from_string, data is the string “Alice-30” because that’s what we passed when we called Person.from_string(“Alice-30”).
The line name, age = data.split(“-”) takes that string and splits it at the — into two parts:
“Alice-30” → [“Alice”, “30”]
Then, name gets “Alice”, and age gets “30”.
int(age) turns the string “30” into the number 30 because age in __init__ expects a number, not a string.
Finally, cls(name, int(age)) is like saying Person(“Alice”, 30) — it creates a new Person object using the class (cls) and returns it.

4. How It All Comes Together

p = Person.from_string(“Alice-30”) calls the class method.
data starts as “Alice-30”, gets split into name = “Alice” and age = “30”, and then makes a Person object with those values.
p becomes a Person object with p.name = “Alice” and p.age = 30.

Wrap-Up

Try practicing more with InstanceTracker to log creation times or extend Person with more parsing options. Happy Coding!!

Python Intermediate_012:Python’s Magic Methods in Classes(Overview)

codeaddict — Sat, 5 Apr 2025 21:31:14 +0900

If you’ve been playing with Python classes, you might’ve heard of “magic methods” — those special methods with double underscores (like __init__). They’re not as mysterious as they sound — they just let you customize how your objects behave. In this post, we’ll cover what they are, why they matter, and give a quick peek at some common ones. Next time, we’ll dig into each one deeper. Let’s get started!

1. What Are Magic Methods?

Magic methods (or “dunder” methods, short for “double underscore”) are built-in Python methods you can define in your classes. They control how objects work with Python’s operators, functions, and features — like addition, printing, or comparisons. You don’t call them directly; Python does it behind the scenes.

For example:

__init__ sets up a new object.
__str__ decides what print() shows.

They’re “magic” because they hook into Python’s core behavior, letting you tweak it without extra code.

2. Why Use Them?

Customization: Make objects act how you want (e.g., adding two objects with +).
Readability: Control what shows up when you print an object.
Power: Tap into Python’s built-in tools (like len() or ==) for your classes.

They’re optional — if you don’t define them, Python uses defaults. But adding them makes your classes more useful.

3. A Quick Tour of Common Magic Methods

Here’s a rundown of some key ones. We’ll keep it simple — just what they do and a basic example. Full details come in the next lesson!

init(self, …)

What It Does: Runs when you create a new object. Sets up initial values.

Example:

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(3, 4)  # __init__ sets x=3, y=4

str(self)

What It Does: Defines what print() shows for your object.

Example:

class Point:
    def __str__(self):
        return f"Point({self.x}, {self.y})"

p = Point(3, 4)
print(p)  # Outputs: Point(3, 4)

add(self, other)

What It Does: Lets you use + to add two objects.

Example:

class Point:
    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

p1 = Point(1, 2)
p2 = Point(3, 4)
p3 = p1 + p2  # p3 is Point(4, 6)

eq(self, other)

What It Does: Decides if two objects are equal with ==.

Example:

class Point:
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

p1 = Point(1, 2)
p2 = Point(1, 2)
print(p1 == p2)  # True

len(self)

What It Does: Lets len() work on your object.

Example:

class Bag:
    def __init__(self, items):
        self.items = items
    def __len__(self):
        return len(self.items)

b = Bag([1, 2, 3])
print(len(b))  # 3

4. How They Fit Together

Here’s a tiny class using a few at once:

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __str__(self):
        return f"({self.x}, {self.y})"
    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

p1 = Point(1, 2)
p2 = Point(3, 4)
p3 = p1 + p2
print(p3)  # Outputs: (4, 6)

5. What’s Next?

This is just the start — Python has a bunch of magic methods to explore. They’re called dunder methods because of the double underscores (__) around their names. “Dunder” is shorthand for “double under” — a nickname Python folks use since they’re special methods tied to how Python works under the hood.

Why the Double Underscores?

You might wonder: why __len__ instead of just len? The double underscores mark these as reserved names — Python’s way of saying, “Hey, these are mine, but you can customize them.” They’re like hooks built into the language. When you write len(obj), Python doesn’t call a plain len method — it looks for __len__ in your class and runs that. The __ keeps them separate from your own method names (like calculate or show), avoiding clashes.

How Do You Use Them?

You define them in your class with the exact name (like def __len__(self):), add self as the first argument (since they’re class methods), and tell Python what to do. Python calls them automatically when you use the matching feature:

obj + other → __add__
print(obj) → __str__
len(obj) → __len__

Why Not Just len?

If it was just len, it’d conflict with the built-in len() function — or any method you might name len for something else. The __len__ name is a contract: Python knows to look for it when len() is called, and you get to decide what “length” means for your object. It’s about giving you control while keeping things organized.

The Big List

Here’s a rundown of the most important dunder methods:

__init__(self, …): Creates a new object.
__str__(self): Controls print() output.
__repr__(self): Gives a detailed string for debugging.
__add__(self, other): Handles +.
__sub__(self, other): Handles -.
__mul__(self, other): Handles *.
__truediv__(self, other): Handles /.
__eq__(self, other): Checks ==.
__lt__(self, other): Checks <.
__gt__(self, other): Checks >.
__le__(self, other): Checks <=.
__ge__(self, other): Checks >=.
__ne__(self, other): Checks !=.
__len__(self): Works with len().
__getitem__(self, key): Enables obj[key].
__setitem__(self, key, value): Enables obj[key] = value.
__del__(self): Runs when an object is deleted.
__call__(self, …): Lets you call an object like a function.

Each one ties to a specific Python feature, and the __ makes them distinct. In the next tutorials, I’ll break down the most important ones — like __init__, __str__, __add__, and __len__ — with examples and tips. For now, try adding a couple to your own class and see what you can make happen!

Python Intermediate_011: Recursive Functions in Python

codeaddict — Sat, 5 Apr 2025 21:30:02 +0900

Recursive functions are a powerful programming concept where a function calls itself to solve a problem by breaking it into smaller, similar subproblems. In this tutorial, we’ll explore recursion in depth, starting with the basics and moving on to more complex problems.

1. What Are Recursive Functions?

A recursive function solves a problem by calling itself with a modified input, reducing the problem size until it reaches a base case — a condition that stops the recursion. It consists of two key parts:

Base Case: The condition that stops the recursion.
Recursive Case: The part where the function calls itself with a smaller or simpler input.

Think of recursion like a stack of tasks: each call adds a layer, and the base case starts resolving them backward.

2. Simple Example: Factorial of a Number

The factorial of a number n (denoted as n!) is the product of all positive integers up to n. For example, 4!=4×3×2×1=24.

Here’s a recursive function to calculate the factorial:

def factorial(n):
    if n == 1:  # Base case
        return 1
    else:  # Recursive case
        return n * factorial(n - 1)

print(factorial(4))  # Output: 24

How It Works:

factorial(4) → 4 * factorial(3)
factorial(3) → 3 * factorial(2)
factorial(2) → 2 * factorial(1)
factorial(1) → 1 (base case hit)

Then, the results are computed back up:

2×1=2
3×2=6
4×6=24

3. Why Use Recursion?

Recursion is ideal for problems with natural hierarchical or repetitive structures, such as:

Calculating factorials or Fibonacci numbers.
Traversing trees or graphs (e.g., file directories).
Solving puzzles like the Tower of Hanoi.

However, recursion can be memory-intensive due to the call stack, and it may not always be the most efficient solution.

4. More Complex Example: Fibonacci Sequence

The Fibonacci sequence is a series of numbers where each number is the sum of the two preceding ones (e.g., 0,1,1,2,3,5,8,…0,1,1,2,3,5,8,…). Here’s a recursive implementation:

def fibonacci(n):
    if n <= 1:  # Base case
        return n
    else:  # Recursive case
        return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(5))  # Output: 5

How It Works:

fibonacci(5) → fibonacci(4) + fibonacci(3)
fibonacci(4) → fibonacci(3) + fibonacci(2)
fibonacci(3) → fibonacci(2) + fibonacci(1)
fibonacci(2) → fibonacci(1) + fibonacci(0)
fibonacci(1) → 1 (base case)
fibonacci(0) → 0 (base case)

The results are summed back up to compute the final value.

5. Problem 1: Power of a Number

Problem: Write a recursive function to calculate the power of a number, e.g., 2³=8.

def power(base, exp):
    if exp == 0:  # Base case
        return 1
    else:  # Recursive case
        return base * power(base, exp - 1)

print(power(2, 3))  # Output: 8

Explanation:

power(2, 3) → 2 * power(2, 2)
power(2, 2) → 2 * power(2, 1)
power(2, 1) → 2 * power(2, 0)
power(2, 0) → 1 (base case)

Then, the results are computed back up:

2×1=2
2×2=4
2×4=8

6. Problem 2: Binary Search Using Recursion

Problem: Implement a recursive binary search algorithm to find an element in a sorted list.

def binary_search(arr, target, low, high):
    if low > high:  # Base case: element not found
        return -1
    mid = (low + high) // 2
    if arr[mid] == target:  # Base case: element found
        return mid
    elif arr[mid] > target:  # Search in the left half
        return binary_search(arr, target, low, mid - 1)
    else:  # Search in the right half
        return binary_search(arr, target, mid + 1, high)

arr = [1, 3, 5, 7, 9, 11]
target = 7
result = binary_search(arr, target, 0, len(arr) - 1)
print(f"Element found at index: {result}")  # Output: 3

Explanation:

The function checks the middle element of the array.
If the middle element is the target, it returns the index.
If the target is smaller, it searches the left half; if larger, it searches the right half.
The process repeats until the target is found or the search space is exhausted.

7. Problem 3: Recursive List Sum

Problem: Write a recursive function to calculate the sum of all elements in a list.

def list_sum(arr):
    if not arr:  # Base case: empty list
        return 0
    else:  # Recursive case
        return arr[0] + list_sum(arr[1:])

arr = [1, 2, 3, 4, 5]
print(list_sum(arr))  # Output: 15

Explanation:

The function adds the first element of the list to the sum of the remaining elements.
The process repeats until the list is empty.

— Key Takeaways

Recursion is a powerful tool for solving problems that can be broken into smaller, similar subproblems.
Always define a base case to stop the recursion.
Recursion can be memory-intensive, so use it judiciously.

Python Intermediate_010: Inheritance in Python

codeaddict — Sat, 5 Apr 2025 21:28:20 +0900

Inheritance is a powerful concept in Object-Oriented Programming (OOP) that allows a class (called a child class) to inherit attributes and methods from another class (called a parent class). This promotes code reusability and makes it easier to create and maintain complex programs. In this tutorial, we’ll cover inheritance with practical examples. We’ll also explain the role of super() in inheritance.

1. What is super()?

The super() function is used to call a method from the parent class. It is commonly used in the __init__ method of a child class to ensure that the parent class’s __init__ method is called. This is important when the child class adds new attributes but still needs to initialize the attributes inherited from the parent class.

Key Points About super()

Purpose: To call a method (usually __init__) from the parent class.
When to Use: When the child class has its own __init__ method and needs to initialize inherited attributes.
How It Works: super().__init__(...) calls the parent class’s __init__ method.

2. Example_1: Modeling Shapes with Inheritance

Let’s start with a practical example where we model shapes. The parent class Shape provides a color attribute, and the child classes Rectangle and Circle use or modify it while calculating areas.

Parent Class: Shape

class Shape:
    def __init__(self, color):
        self.color = color  # Inherited property
    
    def area(self):
        return 0  # Default area for a generic shape
    
    def describe(self):
        return f"This is a {self.color} shape with area {self.area()}"

Child Class: Rectangle

class Rectangle(Shape):
    def __init__(self, color, length, width):
        super().__init__(color)  # Inherit color from Shape,  Call parent's __init__ to initialize color
        self.length = length
        self.width = width
    
    def area(self):  # Override parent's area method
        return self.length * self.width
    
    def change_color(self, new_color):  # Modify inherited color
        self.color = new_color
        return f"Rectangle color changed to {self.color}"

Child Class: Circle

class Circle(Shape):
    def __init__(self, color, radius):
        super().__init__(color)  # Inherit color from Shape
        self.radius = radius
    
    def area(self):  # Override parent's area method
        return 3.14 * self.radius * self.radius
    
    def describe(self):  # Override parent's describe method
        return f"This is a {self.color} circle with area {self.area():.2f}"

Using the Classes

# Create objects with numbers
rect = Rectangle("Blue", 4, 5)
circ = Circle("Red", 3)

# Test using inherited color and numeric calculations
print(rect.describe())          # Output: This is a Blue shape with area 20
print(rect.change_color("Green"))  # Output: Rectangle color changed to Green
print(rect.describe())          # Output: This is a Green shape with area 20
print(circ.describe())          # Output: This is a Red circle with area 28.26

Explanation of the Shape Example

Parent Class (Shape):

Defines a color attribute that is inherited by child classes.
Provides a default area method (returns 0 for a generic shape).
Has a describe method that uses the inherited color and area.

Child Class (Rectangle):

Inherits color and uses it in the describe method.
Adds length and width attributes to calculate the area (length * width).
Uses super().__init__(color) to initialize the inherited color attribute.
Includes a change_color method to modify the inherited color.

Child Class (Circle):

Inherits color and uses it in an overridden describe method.
Adds a radius attribute to calculate the area (3.14 * radius * radius).
Uses super().__init__(color) to initialize the inherited color attribute.

Numeric Breakdown:

Rectangle: length = 4, width = 5 → Area = 4 * 5 = 20.
Circle: radius = 3 → Area = 3.14 * 3 * 3 = 28.26.

Role of super():

In both Rectangle and Circle, super().__init__(color) ensures that the color attribute is initialized by the Shape class.
Without super(), the color attribute would not be initialized, and the program would throw an error.

3. Example_2: Inheritance with Numeric Calculations

Now, let’s explore another example involving numeric calculations to further solidify your understanding of inheritance and super().

Parent Class: Calculator

class Calculator:
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def add(self):
        return self.a + self.b

    def subtract(self):
        return self.a - self.b

Child Class: AdvancedCalculator

class AdvancedCalculator(Calculator):
    def multiply(self):
        return self.a * self.b

    def divide(self):
        if self.b != 0:
            return self.a / self.b
        else:
            return "Division by zero is not allowed!"

Using the Classes

# Create an instance of AdvancedCalculator
calc = AdvancedCalculator(10, 5)

# Use methods from both parent and child classes
print("Addition:", calc.add())          # Output: Addition: 15
print("Subtraction:", calc.subtract())  # Output: Subtraction: 5
print("Multiplication:", calc.multiply())  # Output: Multiplication: 50
print("Division:", calc.divide())       # Output: Division: 2.0

Explanation of the Calculator Example

Parent Class (Calculator):

Defines basic arithmetic operations (add and subtract).
Initializes two numbers (a and b).

Child Class (AdvancedCalculator):

Inherits add and subtract methods from Calculator.
Adds advanced operations like multiply and divide.

- Why super() Wasn’t Used in AdvancedCalculator

In the AdvancedCalculator class, we didn’t use super() because the parent class (Calculator) already initializes the attributes a and b in its __init__ method. When the AdvancedCalculator class inherits from Calculator, it automatically gains access to all the attributes and methods of the parent class, including a and b.

- Key Difference Between the Two Examples

— Example 1: Rectangle Class

In the Rectangle class, we added new attributes (length and width) in addition to inheriting the color attribute from the Shape class. Since the child class (Rectangle) has its own __init__ method, we need to explicitly call the parent class’s __init__ method using super() to initialize the inherited color attribute.

— Example 2: AdvancedCalculator Class

In the AdvancedCalculator class, we did not add any new attributes. It simply inherits the a and b attributes from the Calculator class. Since the child class (AdvancedCalculator) doesn’t have its own __init__ method, Python automatically calls the parent class’s __init__ method to initialize a and b.

4. Challenge for Readers

Problem: Create a BankAccount class with attributes account_number and balance. Then, create a SavingsAccount class that inherits from BankAccount and adds an attribute interest_rate. Finally, create a FixedDeposit class that inherits from BankAccount and adds an attribute duration.

Solution:

class BankAccount:
    def __init__(self, account_number, balance):
        self.account_number = account_number
        self.balance = balance

    def display_balance(self):
        return f"Account {self.account_number} has a balance of ${self.balance}."

class SavingsAccount(BankAccount):
    def __init__(self, account_number, balance, interest_rate):
        super().__init__(account_number, balance)  # Call parent's __init__
        self.interest_rate = interest_rate  # Add new attribute

    def calculate_interest(self):
        return self.balance * self.interest_rate / 100

class FixedDeposit(BankAccount):
    def __init__(self, account_number, balance, duration):
        super().__init__(account_number, balance)  # Call parent's __init__
        self.duration = duration  # Add new attribute

    def display_duration(self):
        return f"Fixed Deposit Account {self.account_number} has a duration of {self.duration} months."

# Example usage
savings = SavingsAccount("SA123", 1000, 5)
fixed_deposit = FixedDeposit("FD456", 5000, 12)

print(savings.display_balance())  # Output: Account SA123 has a balance of $1000.
print("Interest:", savings.calculate_interest())  # Output: Interest: 50.0
print(fixed_deposit.display_balance())  # Output: Account FD456 has a balance of $5000.
print(fixed_deposit.display_duration())  # Output: Fixed Deposit Account FD456 has a duration of 12 months.

By practicing these examples, you’ll gain a solid understanding of inheritance in Python.

Python Intermediate_009: Lambda Functions in Python

codeaddict — Sat, 5 Apr 2025 21:26:59 +0900

Lambda functions, also known as anonymous functions, are a concise way to create small, throwaway functions in Python. They are often used for short, simple operations that are not reused elsewhere in the code. In this tutorial, we’ll cover the syntax of lambda functions, compare them with regular functions, provide examples, and solve problems using both approaches.

1. Syntax of Lambda Functions

The syntax for a lambda function is:

lambda arguments: expression

lambda: The keyword used to define a lambda function.
arguments: The input parameters (similar to a regular function).
expression: A single expression that is evaluated and returned. Lambda functions can only contain one expression.

2. Examples: Lambda vs Regular Functions

Example 1: Adding Two Numbers

Lambda Function:

add = lambda x, y: x + y
print(add(3, 5))  # Output: 8

Regular Function:

def add(x, y):
    return x + y
print(add(3, 5))  # Output: 8

Explanation:

The lambda function is a one-liner and doesn’t require a def statement or a function name.
The regular function is more readable and reusable for larger tasks.

Example 2: Multiplying Two Numbers

Lambda Function:

multiply = lambda x, y: x * y
print(multiply(4, 5))  # Output: 20

Regular Function:

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

print(multiply(4, 5))  # Output: 20

Example 3: Checking if a Number is Even

Lambda Function:

is_even = lambda x: x % 2 == 0
print(is_even(4))  # Output: True
print(is_even(5))  # Output: False

Regular Function:

def is_even(x):
    return x % 2 == 0
print(is_even(4))  # Output: True
print(is_even(5))  # Output: False

Example 4: Concatenating Strings

Lambda Function:

concat = lambda s1, s2: s1 + " " + s2
print(concat("Hello", "World"))  # Output: Hello World

Regular Function:

def concat(s1, s2):
    return s1 + " " + s2
print(concat("Hello", "World"))  # Output: Hello World

3. Problems and Solutions

Problem 1: Square a Number

Task: Write a program to square a number.

Solution with Lambda:

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

Solution with Regular Function:

def square(x):
    return x**2

print(square(5))  # Output: 25

Problem 2: Check if a Number is Positive

Task: Write a program to check if a number is positive.

Solution with Lambda:

is_positive = lambda x: x > 0
print(is_positive(10))  # Output: True
print(is_positive(-5))  # Output: False

Solution with Regular Function:

def is_positive(x):
    return x > 0
print(is_positive(10))  # Output: True
print(is_positive(-5))  # Output: False

Problem 3: Calculate the Area of a Rectangle

Task: Write a program to calculate the area of a rectangle.

Solution with Lambda:

area = lambda length, width: length * width
print(area(10, 5))  # Output: 50

Solution with Regular Function:

def area(length, width):
    return length * width

print(area(10, 5))  # Output: 50

4. When to Use Lambda vs Regular Functions

Use Lambda When:

The function is short and simple.
The function is used only once (throwaway).
You need a quick function for simple operations.

Use Regular Functions When:

The function is complex or has multiple statements.
The function is reused multiple times.
You need better readability and documentation.

cpp_021: Const Modifier in C++

codeaddict — Sat, 5 Apr 2025 20:00:16 +0900

In C++, the const keyword is a powerful tool for controlling how data is used in your program. It allows you to declare variables, parameters, or return values as “constant,” meaning they cannot be modified after initialization. This is crucial for writing safe, predictable code — especially when passing data to functions. In this post, we’ll explore const in a general sense, using examples with variables, arrays, and function interactions to show how it enforces read-only behavior and what happens when we mix const and non-const contexts.

1. Basics of const with Variables

Let’s start simple. The const keyword makes a variable immutable after it’s initialized.

#include <iostream>
using namespace std;

int main() {
    const int x = 5; // x is constant
    // x = 10; // Error: assignment of read-only variable 'x'
    cout << "x = " << x << endl;

    int y = 20; // y is not constant
    y = 30; // Perfectly fine
    cout << "y = " << y << endl;

    return 0;
}

Output:

x = 5
y = 30

Key Point: const int x can’t be changed after initialization, but y (non-const) can. This is the foundation of const: it locks a value in place. This highlights the purpose of const: it locks a value in place to prevent changes. If you attempt to modify x, the compiler will throw an error, as shown in the commented line within the code.

2. Using const in Function Parameters

When you pass data to a function, const ensures the function can’t modify it. Let’s see this with a scalar (single value) and then an array.

Example 1: Scalar Parameter

#include <iostream>
using namespace std;

void printValue(const int x) {
    // x = 50; // Error: assignment of read-only parameter 'x'
    cout << "Inside function, x = " << x << endl;
}

int main() {
    int a = 10;
    printValue(a); // Pass a to the function
    a = 20; // Change a outside the function
    cout << "Outside function, a = " << a << endl;

    return 0;
}

Output:

Inside function, x = 10
Outside function, a = 20

What’s Happening?

const int x is a copy of a. The function can’t modify x, but since it’s a copy, the original a isn’t affected anyway.
Outside the function, a is non-const, so we can change it freely.

Example 2: Array Parameter

Arrays are passed as pointers, not copies, so const becomes more critical.

#include <iostream>
using namespace std;

void printArray(const int arr[], int size) {
    // arr[0] = 100; // Error: assignment of read-only location
    for (int i = 0; i < size; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}

int main() {
    int numbers[] = {1, 2, 3, 4};
    int size = 4;

    printArray(numbers, size); // Array is read-only inside function
    numbers[0] = 10; // Modify outside function
    cout << "After modification: ";
    printArray(numbers, size);

    return 0;
}

Output:

1 2 3 4
After modification: 10 2 3 4

Key Point:

const int arr[] prevents the function from modifying the array’s elements.
Outside the function, numbers is non-const, so we can still change it. The const restriction only applies inside printArray.

3. const Inside vs. Outside Functions

The const keyword’s scope is local to where it’s applied. Data that’s const inside a function can still be modified outside if it’s not declared const there. Let’s explore this further.

Example 3: Mixing const and Non-const

#include <iostream>
using namespace std;

void processData(const int value, const int arr[], int size) {
    cout << "Value = " << value << ", Array = ";
    for (int i = 0; i < size; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}

int main() {
    int num = 5;
    int data[] = {10, 20, 30};

    processData(num, data, 3); // Pass non-const data to const parameters

    num = 15; // Modify num
    data[0] = 100; // Modify data
    cout << "After changes: ";
    processData(num, data, 3);

    return 0;
}

Output:

Value = 5, Array = 10 20 30
After changes: Value = 15, Array = 100 20 30

Explanation:

Inside processData, value and arr are const, so the function can’t change them.
Outside, num and data are non-const, so we can modify them freely. The const in the function doesn’t “lock” the original data — it just restricts what the function can do.

4. Challenges with const and Function Calls

What happens if a function with const parameters needs to call another function? If the second function doesn’t expect const data, you’ll run into issues. Let’s see this in action.

Example 4: Calling a Non-const Function

#include <iostream>
using namespace std;

void modifyArray(int arr[], int size) { // Non-const parameter
    arr[0] = 999;
    cout << "Modified in modifyArray: " << arr[0] << endl;
}

void processArray(const int arr[], int size) {
    cout << "In processArray: " << arr[0] << endl;
    // modifyArray(arr, size); // Error: cannot convert 'const int*' to 'int*'
}

int main() {
    int numbers[] = {1, 2, 3};
    processArray(numbers, 3);
    modifyArray(numbers, 3); // Works fine here
    processArray(numbers, 3);

    return 0;
}

Output:

In processArray: 1
Modified in modifyArray: 999
In processArray: 999

Problem:

processArray takes const int arr[], so arr is read-only. => Because of this, you cannot call modifyArray(arr, size) from within processArray. The reason is that modifyArray expects a non-const array (int arr[]), which it modifies. => The compiler prevents this with an error like: Error: cannot convert ‘const int*’ to ‘int*’”.

Conclusion

The const modifier in C++ is all about control. It lets you:

Protect data inside functions from being modified (const int x, const int arr[]).
Keep flexibility outside functions where data isn’t const.

Whether you’re working with scalars, arrays, or multi-dimensional structures, const helps you write safer, more intentional code. It’s especially valuable in large projects where tracking modifications can get messy.

cpp_020: Multi-Dimensional Arrays vs. Nested std::vector in C++ — Understanding the Basics with Examples

codeaddict — Sat, 5 Apr 2025 19:59:04 +0900

In this tutorial, we explore multi-dimensional collections in C++, including multi-dimensional arrays and nested std::vector structures, which are commonly used to represent data in multiple dimensions, such as matrices or grids.

Throughout this tutorial, we will:

Introduce multi-dimensional C-style arrays and nested std::vector structures.
Demonstrate how to declare and use them with basic examples.
Explain how to pass them to functions.
Present a practical problem and solve it using both approaches.

1- Basics of Multi-Dimensional Arrays and Nested Vectors

1.1 Multi-Dimensional C-Style Arrays

A multi-dimensional array is an array of arrays. For example, a 2D array can represent a matrix with rows and columns. Its size is fixed at compile time.

Declaration:

int arr[rows][cols]; // e.g., int arr[2][3] for 2 rows, 3 columns

1.2 Nested std::vector (Vector of Vectors)

A nested std::vector is a dynamic structure where each element of the outer vector is itself a vector. There are two common ways to declare it:

Pre-sized Declaration:

vector<vector<int>> vec(rows, vector<int>(cols)); // e.g., 2 rows, 3 columns

Creates a vector with rows rows, each containing a vector of cols elements, initialized to 0.

Empty Declaration with Assignment:

vector<vector<int>> vec; // Starts empty
vec = {{1, 2, 3}, {4, 5, 6}}; // Assigns a 2x3 structure

Comparison with Examples:

Let’s see these in action to understand how they differ.

-Pre-sized Example:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    // Declare a 2x3 nested vector (not empty, initialized with 0s)
    vector<vector<int>> vec(2, vector<int>(3));

    // Print initial contents
    cout << "Pre-sized 2x3 Nested Vector (initial):\n";
    for (int i = 0; i < vec.size(); i++) {
        for (int j = 0; j < vec[i].size(); j++) {
            cout << vec[i][j] << " ";
        }
        cout << endl;
    }

    // Assign specific values
    vec[0] = {1, 2, 3}; // Replace row 0
    vec[1] = {4, 5, 6}; // Replace row 1

    // Print updated contents
    cout << "\nPre-sized 2x3 Nested Vector (updated):\n";
    for (int i = 0; i < vec.size(); i++) {
        for (int j = 0; j < vec[i].size(); j++) {
            cout << vec[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

Output:

Pre-sized 2x3 Nested Vector (initial):
0 0 0
0 0 0

Pre-sized 2x3 Nested Vector (updated):
1 2 3
4 5 6

-Empty with Assignment Example:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    // Declare an empty nested vector first
    vector<vector<int>> vec;

    // Print initial size
    cout << "Initial size of empty vector: " << vec.size() << endl;

    // Assign the 2x3 structure in one step
    vec = {{1, 2, 3}, {4, 5, 6}};

    // Print the result
    cout << "\nAssigned 2x3 Nested Vector:\n";
    for (int i = 0; i < vec.size(); i++) {
        for (int j = 0; j < vec[i].size(); j++) {
            cout << vec[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

Output:

Initial size of empty vector: 0

Assigned 2x3 Nested Vector:
1 2 3
4 5 6

Explanation of Differences:

-Pre-sized (vec(rows, vector<int>(cols))):

Immediately creates a 2x3 structure with all elements set to 0.
Size is fixed at declaration (vec.size() == 2, vec[0].size() == 3).
You replace values afterward (e.g., vec[0] = {1, 2, 3}).
Best when you need a specific size upfront and plan to fill it later.

-Empty with Assignment (vec; vec = {…}):

Starts empty (vec.size() == 0), with no structure.
Assignment (vec = {{1, 2, 3}, {4, 5, 6}}) sets the size and values in one step.
Simpler if you have all the data ready and want to initialize it directly.

-Key Difference: The pre-sized method gives you a “blank slate” with a defined shape, while the empty method starts with nothing until you assign the full structure.

2- Key Examples with Explanations

2.1 Basic Usage with Loops

Let’s compare a 2D array and both nested vector declarations, initializing them with {1, 2, 3}, {4, 5, 6} and printing with loops.

Code:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    // 2D C-style array: 2 rows, 3 columns
    int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};

    // Nested vector (pre-sized): 2 rows, 3 columns
    vector<vector<int>> vec1(2, vector<int>(3));
    vec1[0] = {1, 2, 3};
    vec1[1] = {4, 5, 6};

    // Nested vector (empty then assigned): 2 rows, 3 columns
    vector<vector<int>> vec2;
    vec2 = {{1, 2, 3}, {4, 5, 6}};

    // Printing 2D array
    cout << "2D Array:\n";
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }

    // Printing pre-sized nested vector
    cout << "\nPre-sized Nested Vector:\n";
    for (int i = 0; i < vec1.size(); i++) {
        for (int j = 0; j < vec1[i].size(); j++) {
            cout << vec1[i][j] << " ";
        }
        cout << endl;
    }

    // Printing assigned nested vector
    cout << "\nAssigned Nested Vector:\n";
    for (int i = 0; i < vec2.size(); i++) {
        for (int j = 0; j < vec2[i].size(); j++) {
            cout << vec2[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

Output:

2D Array:
1 2 3
4 5 6

Pre-sized Nested Vector:
1 2 3
4 5 6

Assigned Nested Vector:
1 2 3
4 5 6

Explanation:

2D Array: Fixed at 2x3, initialized directly. Loops use hardcoded bounds.
Pre-sized Vector (vec1): Starts as a 2x3 grid of 0s, then updated with values. Size is set at declaration.
Assigned Vector (vec2): Starts empty, then assigned the full structure. Size is set by the assignment.

2.2 Passing to Functions

Let’s pass a 2D array and a nested vector (assigned method) to functions to sum their elements.

Code:

#include <iostream>
#include <vector>
using namespace std;

// Function for 2D array
int sumArray(int arr[][3], int rows) {
    int sum = 0;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 3; j++) {
            sum += arr[i][j];
        }
    }
    return sum;
}

// Function for nested vector
int sumVector(const vector<vector<int>>& vec) {
    int sum = 0;
    for (int i = 0; i < vec.size(); i++) {
        for (int j = 0; j < vec[i].size(); j++) {
            sum += vec[i][j];
        }
    }
    return sum;
}

int main() {
    // 2D array
    int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};

    // Nested vector (assigned method)
    vector<vector<int>> vec;
    vec = {{1, 2, 3}, {4, 5, 6}};

    // Call functions
    cout << "Sum of 2D array: " << sumArray(arr, 2) << endl;
    cout << "Sum of nested vector: " << sumVector(vec) << endl;

    return 0;
}

Output:

Sum of 2D array: 21
Sum of nested vector: 21

Explanation:

2D Array: Requires column size in the parameter (int arr[][3]).

When passing a 2D C-style array to a function, the syntax int arr[][3] is used. Here’s what this means and why it’s required:

Column Size (Fixed): The 3 in int arr[][3] specifies the number of columns, and it must be provided at compile time. This is because a 2D array in C++ is stored in memory as a contiguous block, and the compiler needs to know the column size to calculate the memory offset for each element. For example, to access arr[i][j], the compiler computes the address as base_address + (i * columns + j) * sizeof(int). Without the column size (3), it can’t determine where each row ends and the next begins.
Row Size (Flexible): The number of rows (the first dimension) is not fixed in the function parameter and can be passed as a separate argument (e.g., int rows). The empty brackets [] indicate that the function can accept a 2D array with any number of rows, as long as each row has exactly 3 columns. This makes the function reusable for arrays like int arr1[2][3] or int arr2[5][3], but the column size remains constant.
Why Fixed Columns? Unlike std::vector, a C-style array’s size is determined at compile time and can’t change at runtime. The column size being fixed in the parameter reflects this static nature. If you tried to use int arr[][] (no sizes specified), the compiler would throw an error because it lacks the information needed to navigate the array’s memory layout.
Example Context: In the function sumArray(int arr[][3], int rows), the 3 ensures the function knows each row has 3 elements, while rows (passed as 2 in the example) tells it how many rows to process. This combination allows the function to work with the fixed 2x3 array {{1, 2, 3}, {4, 5, 6}}.

Nested Vector: Passed by reference, works with either method after initialization.

When passing a nested std::vector (e.g., vector<vector<int>>) to a function, it’s typically passed by const reference (e.g., const vector<vector<int>>& vec). Here’s a deeper look at how this works and what vec[i].size() means:

Passed by Reference: The & in const vector<vector<int>>& vec means the vector is passed by reference, not copied. This is crucial because a nested vector can be large, and copying it would be slow and memory-intensive. The const ensures the function won’t modify the vector, making it safe for read-only operations like summing elements.
Dynamic Sizes: Unlike a 2D array, a nested vector’s sizes (both rows and columns) are dynamic and determined at runtime. The outer vector’s size (vec.size()) is the number of rows, and each inner vector’s size (vec[i].size()) is the number of columns in row i. These sizes aren’t fixed at compile time — they’re stored as part of the vector’s internal data and can vary.
What is vec[i].size()?
vec is the outer vector, and vec[i] accesses the i-th inner vector (a row).
vec[i].size() returns the number of elements (columns) in that specific row. For example, in vec = {{1, 2, 3}, {4, 5, 6}}, vec[0].size() is 3 because the first row has 3 elements (1, 2, 3).

3- Problem and Solution

Problem: Transpose a 2x3 matrix into a 3x2 matrix using a 2D array and a nested vector (pre-sized method).

Solution:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    // 2D array: 2x3
    int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};
    int arrT[3][2];

    // Nested vector (pre-sized): 2x3
    vector<vector<int>> vec(2, vector<int>(3));
    vec[0] = {1, 2, 3};
    vec[1] = {4, 5, 6};
    vector<vector<int>> vecT(3, vector<int>(2));

    // Transpose 2D array
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            arrT[j][i] = arr[i][j];
        }
    }

    // Transpose nested vector
    for (int i = 0; i < vec.size(); i++) {
        for (int j = 0; j < vec[i].size(); j++) {
            vecT[j][i] = vec[i][j];
        }
    }

    // Print results
    cout << "Transposed 2D Array (3x2):\n";
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 2; j++) {
            cout << arrT[i][j] << " ";
        }
        cout << endl;
    }

    cout << "\nTransposed Nested Vector (3x2):\n";
    for (int i = 0; i < vecT.size(); i++) {
        for (int j = 0; j < vecT[i].size(); j++) {
            cout << vecT[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

Output:

Transposed 2D Array (3x2):
1 4 
2 5 
3 6 

Transposed Nested Vector (3x2):
1 4 
2 5 
3 6

Explanation:

2D Array: Fixed sizes, transposed by swapping indices.
Nested Vector: Pre-sized method used for consistency, transposed similarly.

cpp_019: Writing to Files with ofstream in C++

codeaddict — Sat, 5 Apr 2025 19:57:48 +0900

When you need to save data from your C++ program to a file, ofstream (output file stream) is what you'll use. It's part of the <fstream> library and works similarly to writing to the console with cout, but instead sends data to a file.

Basic Syntax

First, you need to include the right header:

#include <fstream>

Creating and using an ofstream has three main steps:

Create an ofstream object and open a file
Check if the file opened successfully
Write data to the file
Close the file (automatically happens when the object is destroyed, but good to do explicitly)

#include <fstream> // Include this to use ofstream

std::ofstream file;              // Create an ofstream object
file.open("filename.txt");       // Open a file (creates it if it doesn’t exist)
file << "Stuff to write";        // Write to the file
file.close();

#include <fstream>: Brings in the file-handling tools.
std::ofstream file;: Makes an object called file (name it whatever you want).
file.open(“filename.txt”): Opens (or creates) the file in the same folder as your program.
file << “text”: Uses the << operator (like cout) to write.
file.close(): Shuts the file to save changes and free resources.

You can also combine opening and creating in one line:

std::ofstream file("filename.txt");

Example 1: Writing a Simple Message

Let’s start basic — writing a line to a file.

#include <fstream>
#include <string>

int main() {
    std::ofstream file("message.txt");
    file << "Hello from C++!\n"; // \n adds a newline
    file.close();
    return 0;
}

What Happens:

Creates (or overwrites) message.txt in your program’s folder.
Writes “Hello from C++!” to it.
Closes the file.

Key Parts:

std::ofstream file(“message.txt”): Opens the file right away.
file <<: Sends the text to the file, just like cout.
file.close(): Saves and finishes up.

Check message.txt after running — it’ll have your message!

Example 2: Saving User Input

Now, let’s save something the user types.

#include <fstream>
#include <iostream>
#include <string>

int main() {
    std::ofstream file("note.txt");
    std::string userInput;
    
    std::cout << "Type a note: ";
    std::getline(std::cin, userInput); // Get a full line
    
    file << "Note: " << userInput << "\n";
    file.close();
    
    std::cout << "Saved to note.txt!\n";
    return 0;
}

What Happens:

Asks for input (e.g., “Buy milk”).
Writes “Note: Buy milk” to note.txt.
Tells you it’s saved.

Key Parts:

std::getline(std::cin, userInput): Grabs a whole line (spaces included), unlike cin >>.
file << “Note: “ << userInput: Chains text and the variable together.
File gets created/overwritten in your program’s directory.

Run it, type something, and check note.txt.

cpp_019: Basics of Functions, Methods, Static Methods, and Constructors in C++

codeaddict — Sat, 5 Apr 2025 19:56:41 +0900

This is a beginner-friendly lesson on four key programming ideas: functions, methods, static methods, and constructors. I’ll use the circle and square analogy to make it visual and simple, explain what an object is first, and compare to Python at the end for those familiar with it. No deep OOP yet — just the basics!

1. Object (First, for Context)

What is an Object?

An object is a specific thing in your program — like a real dog, car, or person. It’s made from a blueprint called a class. In our analogy:

Square: The object (a specific thing, like “Buddy the dog”).
Class: The design for all squares (e.g., “Dog blueprint”).
Example: If “Dog” is the class (blueprint), “Buddy” is an object (a square made from it).
Why: Objects let us work with real instances, not just ideas.

2. Function

What is a Function?

A function is a standalone action — a circle floating by itself. It’s not tied to any square (thing). You call it directly to do a task.

Picture: A single circle, like a button labeled “Say Hello.”
Purpose: Does a job anytime you need it, like printing or calculating.

Example

#include <iostream>

// Function (a lone circle)
void sayHello() {
    std::cout << "Hello!" << std::endl;
}

int main() {
    sayHello(); // Press the circle button => Output: Hello!
    return 0;
}

3. Method

What is a Method?

A method is an action (circle) that belongs inside a specific square (object). It’s something the object can do, and you call it with a dot: square.circle().

Picture: A square (the object) with a circle inside labeled “Bark.”
Purpose: Lets a specific thing perform its own actions.

Example

#include <iostream>

class Dog { // Blueprint for squares
public:
    std::string name;

    // Method (circle inside the square)
    void bark() {
        std::cout << name << " says Woof!" << std::endl;
    }
};

int main() {
    Dog myDog;        // A square (object)
    myDog.name = "Buddy";
    myDog.bark();     // Press the circle inside myDog => Output: Buddy says Woof!
    return 0;
}

Explanation:

myDog is the square (object).
bark() is the circle inside it. You call it with myDog.bark() because it’s tied to that square.

Another Example (std::string)

#include <iostream>
#include <string>

int main() {
    std::string name = "Jane"; // A square (string object)
    int len = name.length();   // Circle inside the square => Output: 4
    std::cout << "Length: " << len << std::endl;
    return 0;
}

Explanation: name is a square, and length() is its circle. You call name.length().

4. Static Method

What is a Static Method?

A static method is an action (circle) attached to the class blueprint (the square’s design), not a specific square (object). It works for the whole group, not one instance.

Picture: A big square labeled “User Blueprint” with a circle stuck to its edge labeled “Show Count.”
Purpose: Does something related to all objects of that type, not one specific object.

Example

#include <iostream>

class User { // Blueprint for squares
public:
    static int count; // Shared by all squares

    // Static method (circle on the blueprint)
    static void showCount() {
        std::cout << "Total users: " << count << std::endl;
    }
};

int User::count = 0; // Set up the shared number

int main() {
    User::count = 2;    // Set total users
    User::showCount();  // Press the circle on the blueprint => Output: Total users: 2
    return 0;
}

Explanation:
User is the blueprint (big square).
showCount() is a circle on the blueprint’s edge. Call it with User::showCount() — no specific square needed.

Method vs. Static Method

Method: Inside a square (e.g., user1.speak() — one user speaks).
Static Method: On the blueprint (e.g., User::showCount() — counts all users).

5. Constructor

What is a Constructor?

A constructor is a special action (circle) that builds a new square (object) when you create it. It runs automatically to set up the object’s starting stuff.

Example

#include <iostream>

class User { // Blueprint for squares
public:
    std::string name;

    // Constructor (circle that builds the square)
    User(std::string userName) {
        name = userName;
    }

    void speak() { // Method (circle inside the square)
        std::cout << "Hi, I’m " << name << std::endl;
    }
};

int main() {
    User user1("Jane"); // Magic circle builds square user1
    User user2("Sara"); // Magic circle builds square user2
    user1.speak();      // Output: Hi, I’m Jane
    user2.speak();      // Output: Hi, I’m Sara
    return 0;
}

Explanation:
User(std::string userName) is the constructor circle. It builds user1 and user2 squares with names.

Constructor vs. Function

Function: A free circle you call anytime (e.g., sayHello()).
Constructor: A circle that builds a square once, when you make it (e.g., User(“Jane”)).

Class vs. Object (Quick Note)

Class: The blueprint (big square design) — e.g., User.
Object: A specific square made from it — e.g., user1, user2.
More Later: In OOP, we’ll dive deeper into this!

Future Topic: Destructor

A destructor is a circle that cleans up a square when it’s done. Preview:

#include <iostream>

class User {
public:
    std::string name;

    User(std::string userName) { // Constructor
        name = userName;
        std::cout << name << " created!" << std::endl;
    }

    ~User() { // Destructor
        std::cout << name << " destroyed!" << std::endl;
    }
};

int main() {
    User user1("Jane"); // Output: Jane created!
    return 0;           // Output: Jane destroyed!
}

Explanation: Automatic Destructor Call

In C++, the destructor (~User()) is a special method that gets called automatically when an object’s lifetime ends. You don’t need to call it yourself with something like ~user1() — C++ handles it for you. Let’s break it down:

Creating the Object:

User user1(“Jane”); creates an object called user1.
This line triggers the constructor (User(std::string userName)), which sets name = “Jane” and prints “Jane created!”.
user1 is now a square (using our analogy) with “Jane” inside it, built by the constructor circle.

2. Object’s Lifetime:

user1 is created inside the main() function. In C++, objects like this have a scope — they only live as long as the block of code they’re in (here, the {} of main()).
While main() is running, user1 exists and is usable.

3. End of Scope:

When return 0; happens, main() finishes, and the program ends.
At this point, the scope of main() closes (the } at the end), and any objects created inside it — like user1 — reach the end of their lifetime.

4. Destructor Runs Automatically:

C++ automatically calls the destructor (~User()) for user1 when it goes out of scope (i.e., when main() ends).
The destructor prints “Jane destroyed!” and cleans up user1 (in this case, just the std::string name is destroyed automatically by its own destructor).

Key Point: You didn’t write ~user1() because you can’t and don’t need to call the destructor manually for objects like this. C++ does it for you when the object’s life is over.

— If you don’t define a destructor, C++ silently provides a default one that automatically cleans up basic member variables (like std::string) when the object’s scope ends.

— When you define a destructor like ~User() { std::cout << name << “ destroyed!” << std::endl; }, it’s just for adding custom actions — like printing a message — since the default cleanup still happens for name; it doesn’t change the memory management here, it only lets you see when the object is destroyed.

Summary with Analogy

Function: Lone circle (action) — sayHello().
Method: Circle inside a square (object’s action) — myDog.bark().
Static Method: Circle on the blueprint (class action) — User::showCount().
Constructor: Magic circle building a square — User(“Jane”).

cpp_018: Switch and Enum in C++

codeaddict — Sat, 5 Apr 2025 19:55:13 +0900

Switch statements and enums are powerful tools in C++ that help you write clean, efficient, and readable decision-making logic. In this tutorial, we’ll explore their syntax, functionality, and practical examples, followed by problems and solutions to reinforce your understanding.

1. Switch Statement

The switch statement allows you to test a variable or expression against multiple cases and execute the corresponding block of code.

Syntax:

switch (expression) {
    case constant1:
        // Code block 1
        break;
    case constant2:
        // Code block 2
        break;
    default:
        // Default code block
}

expression: The variable or value being tested.
case constant: Matches specific values of the expression.
break: Terminates the switch case to prevent "fall-through" execution.
default: Executes if none of the cases match.

2. Enum (Enumeration)

An enum is a user-defined data type that assigns names to integral constants, making your code more readable and maintainable.

Syntax:

enum EnumName {
    constant1,
    constant2,
    constant3,
    // ...
};

Enumerators are automatically assigned integer values starting from 0 unless explicitly specified.

3. Example 1: Simple Switch with Enum

Let’s create a simple program that uses a switch statement with an enum to represent days of the week.

#include <iostream>
using namespace std;

enum Day { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday };

int main() {
    Day today = Friday;

    switch (today) {
        case Monday:
            cout << "It's Monday. Back to work!" << endl;
            break;
        case Friday:
            cout << "It's Friday. The weekend is near!" << endl;
            break;
        case Sunday:
            cout << "It's Sunday. Relax and recharge!" << endl;
            break;
        default:
            cout << "It's a regular weekday." << endl;
    }

    return 0;
}

Output:

It's Friday. The weekend is near!

Explanation:

We define an enum called Day to represent the days of the week.
The switch statement checks the value of today and executes the corresponding case block.
Since today is set to Friday, the program prints the message for Friday.

4. Example 2: Scenario with Explicit Enum Values

In this example, we’ll use an enum with explicitly assigned values and a switch statement to suggest activities based on the weather.

#include <iostream>
using namespace std;

// Define an enum called Weather with explicit integer values for each weather type
enum Weather { Sunny = 1, Cloudy = 2, Rainy = 3, Snowy = 4 };

void suggestActivity(Weather w) {
    switch (w) {
        case Sunny:
            cout << "It's sunny! Go for a walk or a picnic." << endl;
            break;
        case Cloudy:
            cout << "It's cloudy. A perfect day for indoor activities." << endl;
            break;
        case Rainy:
            cout << "It's rainy. Stay indoors and read a book." << endl;
            break;
        case Snowy:
            cout << "It's snowy. Time for some skiing or snowball fights!" << endl;
            break;
        default:
            cout << "Invalid weather type!" << endl;
    }
}

int main() {
    // Declare a variable of type Weather to store the current weather
    Weather currentWeather;

    // Declare an integer variable to store the user's input
    int input;

    // Ask the user to enter a number representing the weather type
    cout << "Enter the weather type (1: Sunny, 2: Cloudy, 3: Rainy, 4: Snowy): ";
    cin >> input;  // Store the user's input in the variable 'input'

    // Convert the integer input to the Weather enum type using static_cast
    currentWeather = static_cast<Weather>(input);

    // Call the suggestActivity function and pass the currentWeather as an argument
    suggestActivity(currentWeather);

    return 0;  // End the program
}

Input/Output:

Enter the weather type (1: Sunny, 2: Cloudy, 3: Rainy, 4: Snowy): 3
It's rainy. Stay indoors and read a book.

Explanation:

We define an enum called Weather with explicit values for each weather type.
The user inputs a number (1–4), which is cast to the Weather type using static_cast.
static_cast is a type of type casting in C++. It is used to explicitly convert one data type to another. It is a compile-time cast, meaning the conversion is checked at compile time, and it is generally considered safe for well-defined conversions.
The switch statement uses the Weather value to suggest an activity.

Why Do We Need static_cast?

In the context of the program, we use static_cast to convert an integer (entered by the user) into an enum value. Here’s why this is necessary:

User Input is an Integer:

When the user enters a number (e.g., 1, 2, 3, or 4), it is stored as an integer (int).
However, the program expects a value of type Weather (which is an enum).

enum Values are Not Directly Compatible with Integers:

Even though enum values are internally represented as integers, the compiler treats them as a distinct type.
You cannot directly assign an integer to an enum variable without an explicit cast.

static_cast Ensures Safe Conversion:

static_cast tells the compiler to treat the integer as a Weather type.
This ensures that the conversion is valid and prevents potential errors.

How Does static_cast Work?

The syntax for static_cast is:

static_cast<NewType>(expression)

NewType: The type you want to convert the expression to.
expression: The value or variable you want to convert.

In the program:

currentWeather = static_cast<Weather>(input);

Weather: The target type (the enum we defined).
input: The integer entered by the user.

This line converts the integer input into a Weather type and assigns it to the variable currentWeather.

5. Key Points to Remember

Always use the break statement in switch cases to avoid unintended fall-through execution.
Use the default case as a fallback for unhandled cases.
Enumerators in enum can be assigned custom values.
Use static_cast to safely convert integers to enum values when required.

Cpp_017: Range-Based For Loops in C++

codeaddict — Sat, 5 Apr 2025 19:53:45 +0900

Range-based for loops, introduced in C++11, provide a clean and concise way to iterate over elements in a container (like arrays, vectors, or strings) without needing explicit indices or iterators. They simplify code and make it more readable, especially for beginners. In this tutorial, we’ll explore the syntax, provide examples, and solve common problems to help you master this powerful feature.

1. Syntax of Range-Based For Loops

The basic syntax is:

for (type variable : container) {
    // Code block
}

Explanation of Syntax

type: The data type of the elements in the container (e.g., int, char, std::string).
variable: A variable that takes the value of each element in the container, one at a time.
container: An iterable object like an array, vector, or string.

You can also use references (&) to modify elements directly or auto for automatic type deduction.

for (int x : arr) {
    // Code block
}

Example of Syntax Usage (In Code)

Here’s how the above analogy translates into code:

#include <iostream>
#include <vector>
using namespace std;  // Add this line to avoid writing std::

int main() {
    int arr[] = {1, 2, 3, 4, 5};

    // Range-based for loop
    for (int x : arr) {
        cout << x << " ";  // Output: 1 2 3 4 5
    }

    return 0;
}

2. Examples of Range-Based For Loops

Example 1: Iterating Over an Array

Let’s start with a simple example of iterating over an array of integers.

#include <iostream>
#include <vector>
using namespace std;  // Add this line

int main() {
    int arr[] = {1, 2, 3, 4, 5};

    // Range-based for loop
    for (int x : arr) {
        cout << x << " ";  // Output: 1 2 3 4 5
    }

    return 0;
}

Explanation:

int x represents each element in the array arr.
The loop automatically iterates over all elements in the array and prints them.

Example 2: Using a Vector

Now, let’s iterate over a std::vector of integers.

#include <iostream>
#include <vector>
using namespace std;  // Add this line

int main() {
    vector<int> vec = {10, 20, 30};

    // Range-based for loop
    for (int x : vec) {
        cout << x << " ";  // Output: 10 20 30
    }

    return 0;
}

Explanation:

The range-based for loop works seamlessly with vector.
It’s a great way to process collections without worrying about indices.

Example 3: Modifying Elements with References

You can use references (&) to modify elements directly in the container.

#include <iostream>
using namespace std;  // Add this line

int main() {
    int arr[] = {1, 2, 3};

    // Range-based for loop with reference
    for (int& x : arr) {
        x *= 2;  // Double each element
    }

    // Print modified array
    for (int x : arr) {
        cout << x << " ";  // Output: 2 4 6
    }

    return 0;
}

Explanation:

int& x is a reference to each element in the array.
Modifying x directly changes the original array elements.

3. Practical Applications

Range-based for loops are ideal for:

Iterating over containers without needing indices.
Processing strings, arrays, or collections cleanly.
Simplifying code when index access isn’t required.

However, they are less flexible than traditional loops (e.g., you can’t easily reverse iterate or skip elements).

4. Problems and Solutions

Problem 1: Print All Characters in a String

Task: Print each character of the string "Hello" separated by a space.

#include <iostream>
#include <string>
using namespace std;  // Add this line

int main() {
    string str = "Hello";

    // Range-based for loop
    for (char c : str) {
        cout << c << " ";  // Output: H e l l o
    }

    return 0;
}

Problem 2: Calculate the Sum of Elements in an Array

Task: Calculate the sum of elements in the array {1, 2, 3, 4, 5}.

#include <iostream>
using namespace std;  // Add this line

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int sum = 0;

    // Range-based for loop
    for (int x : arr) {
        sum += x;
    }

    cout << sum;  // Output: 15
    return 0;
}

Problem 3: Reverse-Print a Vector

Task: Print the elements of the vector {10, 20, 30} in reverse order.

#include <iostream>
#include <vector>
using namespace std;  // Add this line

int main() {
    vector<int> vec = {10, 20, 30};

    // Use reverse iterators
    for (auto it = vec.rbegin(); it != vec.rend(); ++it) {
        cout << *it << " ";  // Output: 30 20 10
    }

    return 0;
}

Explanation:

Range-based for loops don’t natively support reverse iteration.
We use reverse iterators (rbegin() and rend()) as a workaround.
For a deeper understanding of rbegin() and rend(), refer to the end of this tutorial. ====>>>>

5. Key Takeaways

Range-based for loops are clean and concise for iterating over containers.
They are ideal for simple traversals but lack the flexibility of traditional loops.
Use references (&) to modify elements directly.
For reverse iteration, use reverse iterators.

6. Challenge for Readers

Problem: Write a program that uses a range-based for loop to count how many times the letter 'a' appears in the string "banana".

Solution:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string str = "banana";
    int count = 0;

    for (char c : str) {
        if (c == 'a') {
            count++;
        }
    }

    cout << "The letter 'a' appears " << count << " times." << endl;
    return 0;
}

Output:

The letter 'a' appears 3 times.

====>

To understand how reverse iterators like rbegin() and rend() work, refer to the detailed explanation at the end of this tutorial.

What Are Iterators?

Iterators are like pointers that help you traverse (move through) the elements of a container (e.g., an array, vector, or string). They provide a way to access elements without needing to know the underlying structure of the container.

Normal Iterators: Move from the beginning to the end of the container.
Reverse Iterators: Move from the end to the beginning of the container.

What Are vec.rbegin() and vec.rend()?

1. vec.rbegin()

Full Name: Reverse Begin Iterator.
What It Does: It points to the last element of the container.
How It Works: When you use vec.rbegin(), you’re asking for an iterator that starts at the end of the vector and moves backward.

2. vec.rend()

Full Name: Reverse End Iterator.
What It Does: It points to one position before the first element of the container (essentially, the “end” of the reverse iteration).
How It Works: When you use vec.rend(), you’re asking for an iterator that marks the stopping point for reverse iteration.

Visual Representation

Let’s say you have a vector:

vector<int> vec = {10, 20, 30};

Here’s how the elements are stored in memory:

Index:   0    1    2
Value:  10   20   30

Normal Iterators:
vec.begin() points to 10 (index 0).
vec.end() points to one position after 30 (index 3).
Reverse Iterators:
vec.rbegin() points to 30 (index 2).
vec.rend() points to one position before 10 (index -1).

How Reverse Iterators Work

When you use a reverse iterator, it moves backward through the container. Here’s how the loop works:

for (auto it = vec.rbegin(); it != vec.rend(); ++it) {
    cout << *it << " ";  // Output: 30 20 10
}

Step-by-Step Breakdown

Initialization: auto it = vec.rbegin()

it starts at the last element (30).

Condition: it != vec.rend()

The loop continues as long as it hasn’t reached vec.rend() (one position before the first element).

Increment: ++it

Since this is a reverse iterator, ++it moves it backward to the previous element.

Dereference: *it

*it gives the value of the element currently pointed to by it.

cpp_016: Comparing C-Style Arrays, std::array, and std::vector in C++

codeaddict — Sat, 5 Apr 2025 19:51:16 +0900

1- Introduction

In previous tutorials, we explored different ways to handle collections in C++. We started with traditional C-style arrays, then introduced the dynamic std::vector, and most recently discussed the modern std::array in cpp_015: STL Array in C++ (https://medium.com/@staytechrich/list/cpp-c-beginner-053ab9a0ecc3).

We also examined how these types are passed to functions: C-style arrays as pointers, std::array as objects (by value or reference), and std::vector typically by reference to avoid copying.

Now, it’s time to tie it all together! In this tutorial, we’ll:

Summarize the key differences between C-style arrays, std::array, and std::vector.
Show examples highlighting these differences.
Provide an integrated example using all three in one program.

2- Key Differences with Integrated Examples

2.1 Size

C-style array: Fixed, no built-in size method, but size can be calculated with sizeof(arr) / sizeof(arr[0]) in the defining scope.
std::array: Fixed, knows its size via .size().
std::vector: Dynamic, resizes at runtime.

Example:

#include <iostream>
#include <array>
#include <vector>
using namespace std;

int main() {
    int cstyle[3] = {1, 2, 3};           // Fixed, size calculable in scope
    array<int, 3> stlarr = {4, 5, 6};   // Fixed, has .size()
    vector<int> vec = {7, 8, 9};        // Dynamic

    // Calculate size for C-style array
    int cstyleSize = sizeof(cstyle) / sizeof(cstyle[0]);
    cout << "C-style size: " << cstyleSize << " (calculated with sizeof)\n";
    cout << "std::array size: " << stlarr.size() << endl;
    cout << "std::vector size: " << vec.size() << endl;

    vec.push_back(10); // Vector grows
    cout << "std::vector size after push_back: " << vec.size() << endl;

    return 0;
}

Output:

C-style size: 3 (calculated with sizeof)
std::array size: 3
std::vector size: 3
std::vector size after push_back: 4

2.2 Safety

C-style array: No bounds checking.
std::array: .at() checks bounds.
std::vector: .at() checks bounds.

Example:

#include <iostream>
#include <array>
#include <vector>
using namespace std;

int main() {
    int cstyle[3] = {1, 2, 3};
    array<int, 3> stlarr = {4, 5, 6};
    vector<int> vec = {7, 8, 9};

    cout << "C-style at 5: " << cstyle[5] << endl; // Undefined behavior

    try {
        cout << "std::array at 5: " << stlarr.at(5) << endl;
    } catch (const out_of_range& e) {
        cout << "std::array error: " << e.what() << endl;
    }

    try {
        cout << "std::vector at 5: " << vec.at(5) << endl;
    } catch (const out_of_range& e) {
        cout << "std::vector error: " << e.what() << endl;
    }

    return 0;
}

Output (varies for C-style, random value or crash):

C-style at 5: 32764
ERROR!
std::array at 5: std::array error: array::at: __n (which is 5) >= _Nm (which is 3)
std::vector at 5: std::vector error: vector::_M_range_check: __n (which is 5) >= this->size() (which is 3)

2.3 Flexibility

C-style array: Static, no resizing.
std::array: Static, fixed size.
std::vector: Dynamic, can grow/shrink.

#include <iostream>
#include <array>
#include <vector>
using namespace std;

int main() {
    int cstyle[3] = {1, 2, 3};         // Cannot resize
    array<int, 3> stlarr = {4, 5, 6}; // Cannot resize
    vector<int> vec = {7, 8, 9};      // Can resize

    // Print initial values
    cout << "C-style: "; for (int i = 0; i < 3; i++) cout << cstyle[i] << " ";
    cout << "\nstd::array: "; for (int i = 0; i < 3; i++) cout << stlarr[i] << " ";
    cout << "\nstd::vector: "; for (int i = 0; i < 3; i++) cout << vec[i] << " ";

    vec.push_back(10); // Only vector can grow
    cout << "\nstd::vector after push_back: ";
    for (int i = 0; i < vec.size(); i++) cout << vec[i] << " ";
    cout << endl;

    return 0;
}

Output:

C-style: 1 2 3 
std::array: 4 5 6 
std::vector: 7 8 9 
std::vector after push_back: 7 8 9 10

2.4 Performance

C-style array: Fastest (no overhead).
std::array: Nearly as fast.
std::vector: Slightly slower due to dynamic management.

2.5 Function Passing

C-style array: Passed as a pointer.
std::array: Passed by value or reference.
std::vector: Passed by reference.

Example

#include <iostream>
#include <array>
#include <vector>
using namespace std;

int sumCStyle(int arr[], int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) sum += arr[i];
    return sum;
}

int sumSTLArray(const array<int, 3>& arr) {
    int sum = 0;
    for (int i = 0; i < arr.size(); i++) sum += arr[i];
    return sum;
}

int sumVector(const vector<int>& vec) {
    int sum = 0;
    for (int i = 0; i < vec.size(); i++) sum += vec[i];
    return sum;
}

int main() {
    int cstyle[3] = {85, 90, 95};
    array<int, 3> stlarr = {88, 92, 87};
    vector<int> vec = {90, 85, 95};
    vec.push_back(88); // Dynamic growth

    cout << "C-style sum: " << sumCStyle(cstyle, 3) << endl;
    cout << "std::array sum: " << sumSTLArray(stlarr) << endl;
    cout << "std::vector sum: " << sumVector(vec) << endl;

    return 0;
}

Output:

C-style sum: 270
std::array sum: 267
std::vector sum: 358

cpp_015: STL Array in C++

codeaddict — Mon, 10 Mar 2025 20:41:20 +0900

Introduction

The Standard Template Library (STL) array, introduced in C++11, is a fixed-size container that offers a safer and more convenient alternative to traditional C-style arrays. Defined in the <array> header, std::array combines the performance of raw arrays with the benefits of STL containers, such as knowing its own size, bounds checking with certain methods, and compatibility with STL algorithms.

In this lesson, we’ll cover:

What std::array is and how it works.
The syntax for declaring and using std::array.
Examples of working with std::array, including passing it to functions.
Two practice problems for you to solve.

Explanation

The std::array is a container that encapsulates a fixed-size array. Unlike C-style arrays, which are raw pointers to memory and don’t carry size information, std::array is a proper object that provides useful member functions like .size(), .at(), and iterators. It’s also more type-safe and easier to pass to functions since it behaves like a regular object.

Key features:

Fixed size, specified at compile time.
Knows its own size (no need to pass it separately).
Supports STL features like iterators and bounds checking with .at().
Passed by value or reference to functions.

Let’s explore the syntax and examples to see how it works!

Syntax for STL Array

Declaration

#include <array>
std::array<T, N> name;

T: The data type of the elements (e.g., int, double, char).
N: The size of the array (must be a constant known at compile time).
name: The variable name of the array.

Common Member Functions

.size(): Returns the number of elements.
.at(index): Accesses an element with bounds checking (throws an exception if out of bounds).
[index]: Accesses an element without bounds checking (faster but unsafe if misused).
.front(): Returns the first element.
.back(): Returns the last element.

Example of Syntax

#include <iostream>
#include <array>
using namespace std;

int main() {
    // Declare an STL array of 5 integers
    array<int, 5> arr = {10, 20, 30, 40, 50};

    // Access elements
    cout << "First element: " << arr[0] << endl;         // 10
    cout << "Element at index 2: " << arr.at(2) << endl; // 30
    cout << "Size of array: " << arr.size() << endl;     // 5

    return 0;
}

Problems with Old-Style Arrays

Old-style arrays are basic. You write them like this:

int numbers[3] = {5, 10, 15};

But they have issues:

No size info: The array doesn’t “know” how many boxes it has. If you forget the size, you might try to use a box that doesn’t exist, causing errors (called “out of bounds”).
Raw pointers: When you pass this array to a function, C++ doesn’t send the whole row of boxes — it just sends a “pointer” (an address in memory) to the first box. This can confuse beginners and lead to mistakes.
No safety: If you accidentally ask for numbers[10] (way past the 3 boxes), the program might crash or act weird because there’s no check to stop you.

What Makes STL array Better?

The STL array fixes these problems. It’s like a smart row of boxes that:

Knows its size: You tell it how many boxes it has when you create it, and it remembers that number.
Fixed size: Once you set the number of boxes (e.g., 5), you can’t change it. This makes it predictable and safe.
Safer access: It has a way to check if you’re asking for a box that exists (called “bounds checking”).
Acts like an object: You can pass it to functions easily without worrying about pointers.

Simple Example

Problem Statement

Write a program that declares an STL array of integers, passes it to a function, and calculates the sum of its elements.

Solution

#include <iostream>
#include <array>
using namespace std;

// Function to calculate the sum of elements in an STL array
int calculateSum(const array<int, 5>& arr) {  // Passed by const reference for efficiency
    int sum = 0;
    for (int i = 0; i < arr.size(); i++) {
        sum += arr[i];
    }
    return sum;
}

int main() {
    // Declare and initialize an STL array
    array<int, 5> numbers = {1, 2, 3, 4, 5};

    // Pass the array to the function
    int result = calculateSum(numbers);

    cout << "The sum of the array elements is: " << result << endl;

    return 0;
}

Output

The sum of the array elements is: 15

Practice Problems

Problem 1: Finding the Minimum Element

Task: Write a program that:

Creates an STL array of 6 doubles.
Passes it to a function that finds the smallest number.
Prints the result in main().

Hint: Loop through and compare each item to find the smallest.

#include <iostream>
#include <array>
using namespace std;

double findMin(const array<double, 6>& arr) {
    double min = arr[0];
    for (int i = 1; i < arr.size(); i++) {
        if (arr[i] < min) {
            min = arr[i];
        }
    }
    return min;
}

int main() {
    array<double, 6> numbers = {3.5, 1.2, 4.8, 0.9, 2.7, 5.1};
    double result = findMin(numbers);
    cout << "Smallest number: " << result << endl; // Prints 0.9
    return 0;
}

Problem 2: Reversing an STL Array

Task: Write a program that:

Creates an STL array of 4 characters (e.g., {‘A’, ‘B’, ‘C’, ‘D’}).
Passes it to a function that reverses it (e.g., to {‘D’, ‘C’, ‘B’, ‘A’}).
Prints the reversed array in main().

Hint: Swap items from the start and end, moving inward.

#include <iostream>
#include <array>
using namespace std;

void reverseArray(array<char, 4>& arr) {
    for (int i = 0; i < arr.size() / 2; i++) {
        char temp = arr[i];
        arr[i] = arr[arr.size() - 1 - i];
        arr[arr.size() - 1 - i] = temp;
    }
}

int main() {
    array<char, 4> letters = {'A', 'B', 'C', 'D'};
    reverseArray(letters);
    cout << "Reversed array: ";
    for (int i = 0; i < letters.size(); i++) {
        cout << letters[i] << " "; // Prints D C B A
    }
    cout << endl;
    return 0;
}

Here’s how it works step by step:

Swapping Logic:

You start by swapping the element at index 0 with the element at the last index arr.size() - 1.
Then, you swap the element at index 1 with the second-to-last element at index arr.size() - 2, and so on.

2. Why only go up to half?:

When you swap the element at index i with the element at index arr.size() - 1 - i, you're already taking care of two positions: i and arr.size() - 1 - i.
After the first swap, the first and last elements are reversed. After the second swap, the second and second-to-last elements are reversed, and so on.
If you continued swapping beyond arr.size() / 2, you'd essentially start swapping elements that have already been swapped.

3. Example: If the array has 4 elements, say: arr = ['a', 'b', 'c', 'd']:

First iteration: Swap arr[0] and arr[3] → arr = ['d', 'b', 'c', 'a']
Second iteration: Swap arr[1] and arr[2] → arr = ['d', 'c', 'b', 'a']
Now the array is fully reversed, and there’s no need to swap further.

In this case, the loop only needs to run twice (i = 0 and i = 1), which is half the size of the array.

Python Intermediate_008: Understanding Generators in Python

codeaddict — Mon, 10 Mar 2025 20:36:12 +0900

In our previous tutorial (https://codeaddict.tistory.com/entry/Python-Intermediate007-Understanding-property-and-Setter-Decorators-in-Python), we explored how to use @property and @<property_name>.setter to manage class attributes. Today, we’ll dive into generators in Python, a powerful tool for creating iterators in a memory-efficient way. We’ll cover the basics, syntax, and practical examples, and end with some problems for you to solve!

1- What Are Generators?

Generators are a special type of function in Python that allow you to iterate over a sequence of values without storing the entire sequence in memory. They are particularly useful when working with large datasets or infinite sequences.

Generator Function: A function that uses yield to return values one at a time, pausing its state between calls, instead of returning a list or all values at once.
Generator Expression: A compact, memory-efficient alternative to list comprehensions, using parentheses (…) instead of brackets […].
Unlike regular functions that return all data at once, generators produce values on-demand, making them ideal for lazy evaluation.

Key Features:

Lazy Evaluation: Values are generated on-the-fly, one at a time.
Memory Efficiency: Only one value is stored in memory at a time.
Use yield instead of return to produce a sequence of values.

2- Syntax and Execution Order

2–1 Syntax

def my_generator():
    yield 1
    yield 2
    yield 3

yield: Pauses the function and returns a value to the caller. The function resumes from where it left off when next called.

Execution Order:

When the generator function is called, it returns a generator object (but doesn’t start execution).
The generator runs until it hits a yield statement, then pauses and returns the yielded value.
On the next call, it resumes execution from where it paused.

Example: Simple Generator

def simple_generator():
    yield "Python"
    yield "Generators"
    yield "Are"
    yield "Awesome"

# Create a generator object
gen = simple_generator()
# Iterate through the generator
for word in gen:
    print(word)

Output:

Python
Generators
Are
Awesome

2–2 Execution Order with one example

# Generator Function
def my_generator():
    n = 0
    while n < 3:
        yield n
        n += 1

# Generator Expression
gen_expr = (x * 2 for x in range(5))

# Usage
gen = my_generator()
for value in gen:
    print(value)  # Prints 0, 1, 2

Generator Function: Uses yield to produce a value and suspend execution until the next call (e.g., via a next() or loop).
Generator Expression: Similar to list comprehensions but generates values lazily.

Execution Order

Function Definition: The generator function is defined, but no code runs until called.
Generator Creation: Calling my_generator() returns a generator object without executing the body.
Value Generation: Each next(gen) or loop iteration resumes execution at the last yield, producing the next value.
Exhaustion: The generator stops when it encounters a return or the end of the function.

3- Simple Problems and Solutions

Problem 1: Create a Generator for Even Numbers

Write a generator function that yields even numbers from 0 to 10. Solution:

def ev_num(n):
    for i in range(n + 1):  # Loop from 0 to n
        if i % 2 == 0:  # Check if the current number (i) is even
            yield i  # Yield the even number

# Specify n outside the function
n = 10
gen1 = ev_num(n)  # Create generator object

# Iterate through the generator
for a in gen1:
    print(a)

Output:

Problem 2: Use a Generator Expression

Create a generator expression to double numbers from 1 to 5 and print them.

Solution:

gen_expr = (x * 2 for x in range(1, 6))
for value in gen_expr:
    print(value)  # Outputs: 2, 4, 6, 8, 10

4- Challenging Problems for Readers

Now, test your skills with these more complex generator problems. Try solving them before checking the solutions below!

Problem 3: Infinite Fibonacci Sequence

Write a generator function that produces an infinite Fibonacci sequence (0, 1, 1, 2, 3, 5, 8, …). Use it to print the first 10 numbers.

The infinite Fibonacci sequence is a series of numbers where each number is the sum of the two preceding ones, starting with 0 and 1. It continues indefinitely, producing an unending list of numbers. Here are the first few numbers in the sequence to help you understand:
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, …

- How It Works:

Start with 0 and 1.
Add the last two numbers to get the next one:
0 + 1 = 1
1 + 1 = 2
1 + 2 = 3
2 + 3 = 5
3 + 5 = 8
And so on…

Problem 4: Filtered Prime Number Generator

Create a generator function that yields prime numbers up to a given limit (e.g., 20). A prime number is divisible only by 1 and itself.

4- 1 Solutions to Problems 3&4

Solution to Problem 3: Infinite Fibonacci Sequence

def fibonacci_generator():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fib = fibonacci_generator()
for _ in range(10):
    print(next(fib))  # Outputs: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34

Explanation: The generator uses an infinite loop with yield to produce Fibonacci numbers, updating a and b on each iteration.

Solution to Problem 4: Filtered Prime Number Generator

def prime_generator(limit):
    def is_prime(n):
        if n < 2:
            return False
        for i in range(2, int(n ** 0.5) + 1):
            if n % i == 0:
                return False
        return True
    
    for num in range(limit + 1):
        if is_prime(num):
            yield num

primes = prime_generator(20)
for prime in primes:
    print(prime)  # Outputs: 2, 3, 5, 7, 11, 13, 17, 19

Explanation: The is_prime helper function checks for primality, and the generator yields numbers up to the limit that pass this test.

- Algorithm Summary

Here’s a high-level summary of the algorithm used in the code:

Input: A number limit that specifies the upper bound for generating prime numbers.
Process:

For each number num from 0 to limit:
Check if num is prime using the is_prime(n) function.
If num is prime, yield it (make it available to the caller).

3. Primality Test (is_prime(n)):

If n < 2, it’s not prime.
Check if n is divisible by any integer i from 2 to the square root of n.
If n is divisible by any i, it’s not prime.
If no divisors are found, n is prime.

4. Output: A sequence of prime numbers, yielded one at a time, which can be consumed by the caller (e.g., printed, stored, or processed further).

- Example Walkthrough for limit = 10

To solidify understanding, let’s walk through what happens when limit = 10:

num = 0: is_prime(0) returns False (not prime, no yield).
num = 1: is_prime(1) returns False (not prime, no yield).
num = 2: is_prime(2) returns True (prime, yield 2).
num = 3: is_prime(3) returns True (prime, yield 3).
num = 4: is_prime(4) checks divisors 2 (4 % 2 = 0), returns False (not prime, no yield).
num = 5: is_prime(5) checks divisors 2 (5 % 2 = 1), returns True (prime, yield 5).
num = 6: is_prime(6) checks divisors 2 (6 % 2 = 0), returns False (not prime, no yield).
num = 7: is_prime(7) checks divisors 2 (7 % 2 = 1), returns True (prime, yield 7).
num = 8: is_prime(8) checks divisors 2 (8 % 2 = 0), returns False (not prime, no yield).
num = 9: is_prime(9) checks divisors 2 (9 % 2 = 1), 3 (9 % 3 = 0), returns False (not prime, no yield).
num = 10: is_prime(10) checks divisors 2 (10 % 2 = 0), returns False (not prime, no yield).

5- Conclusion

Generators are a powerful feature in Python that enable you to work with sequences in a memory-efficient and elegant way. By mastering generators, you can write cleaner and more efficient code, especially when dealing with large datasets or infinite sequences. Try solving the advanced problems above to deepen your understanding!

Python Intermediate_007: Understanding @property and Setter Decorators in Python

codeaddict — Sun, 9 Mar 2025 18:09:04 +0900

In our last lesson (https://codeaddict.tistory.com/entry/Python-Intermediate006-Decorators-in-Python), we explored basic and practical decorators like access control. Today, we’ll dive into Python’s @property decorator and its companion @<property_name>.setter, which transform methods into manageable attributes. These tools are key for encapsulation in object-oriented programming. We’ll cover syntax, execution order, and some examples!

What Are @property and Setter Decorators?

@property: Converts a method into a getter, letting you access it like an attribute (e.g., obj.name instead of obj.name()).
@<property_name>.setter: Defines a method to set the attribute’s value, often with validation or logic.

These are built-in Python decorators for controlling class attribute access, replacing the need for explicit getter/setter methods.

Syntax and Execution Order

Syntax

class MyClass:
    def __init__(self):
        self._value = 0  # Private-ish attribute (convention with underscore)

    @property
    def value(self):  # Getter
        return self._value

    @value.setter
    def value(self, new_value):  # Setter
        self._value = new_value

Getter: @property decorates a method to act as an attribute.
Setter: @value.setter (note the dot notation) decorates a method to handle assignment.

Execution Order

Here’s how it works when using these decorators:

Class Definition: Python registers the @property and @<property_name>.setter methods during class creation.
Object Creation: The __init__ method initializes the underlying attribute (e.g., _value).
Getter Call: Accessing obj.value invokes the @property-decorated method.
Setter Call: Assigning obj.value = x invokes the @value.setter-decorated method.

Example Flow

obj = MyClass()
print(obj.value)  # Step 3: Calls the getter
obj.value = 42    # Step 4: Calls the setter
print(obj.value)

Step-by-Step Explanation

obj = MyClass()

What Happens: Creates an instance of MyClass. The __init__ method runs, setting self._value = 0 (the initial value).
Function Run: __init__
Printed: Nothing is printed yet.

2. print(obj.value) (First print)

What Happens: Accesses obj.value, which triggers the @property-decorated value method (the getter). This method returns self._value, which is currently 0.
Function Run: The getter method value(self) under @property.
Printed: The value returned by the getter, which is 0. So, it prints:

3. obj.value = 42

What Happens: Assigns 42 to obj.value, triggering the @value.setter-decorated value method (the setter). The setter updates self._value to 42.
Function Run: The setter method value(self, new_value) under @value.setter.
Printed: Nothing is printed by default (unless the setter has a print statement, which the base example doesn’t). The value of self._value is now 42.

4. print(obj.value) (Second print)

What Happens: Accesses obj.value again, calling the @property-decorated getter method. It returns self._value, which is now 42.
Function Run: The getter method value(self) under @property.
Printed: The updated value, which is 42. So, it prints:

Practical Example: Managing Employee Salary

Problem Definition

You’re designing a system to manage employee data. Each employee has a salary, but:

The salary must not be negative (validation required).
You want to access and update it like an attribute (e.g., emp.salary instead of emp.get_salary()).
Updates should log changes for auditing.

How would you implement this? Try solving it before scrolling down!

Solution

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self._salary = salary  # Private-ish attribute

    @property
    def salary(self):
        print(f"   → Fetching salary for {self.name}")
        return self._salary

    @salary.setter
    def salary(self, new_salary):
        if new_salary < 0:
            print("Error: Salary cannot be negative!")
            return  # Ignore invalid updates
        print(f"1. Updating salary for {self.name} to {new_salary}")
        self._salary = new_salary

# Test it
print("START")
emp = Employee("Alice", 50000)
print(f"Initial salary: {emp.salary}")
emp.salary = 60000  # Update salary
print(f"New salary: {emp.salary}")
emp.salary = -1000  # Try invalid update
print(f"Final salary: {emp.salary}")
print("END")

Output

START
   → Fetching salary for Alice
Initial salary: 50000
1. Updating salary for Alice to 60000
   → Fetching salary for Alice
New salary: 60000
Error: Salary cannot be negative!
   → Fetching salary for Alice
Final salary: 60000
END

Detailed Explanation

Class Setup: Employee uses _salary as a pseudo-private attribute (underscore convention).
@property: The salary method becomes a getter. Accessing emp.salary runs this method, logging the fetch and returning _salary.
@salary.setter: The setter validates new_salary. If negative, it rejects the change; otherwise, it updates _salary and logs it.
Execution:

emp.salary (getter) fetches the initial value (50000).
emp.salary = 60000 (setter) updates it with validation.
emp.salary = -1000 (setter) fails due to the check, keeping the value at 60000.

This encapsulates _salary, enforces rules, and provides a clean interface.

Summary

@property: Turns methods into readable attributes.
@<property_name>.setter: Adds logic to attribute assignment (e.g., validation).
Practical Use: Ideal for managing data like salaries or settings with control.

cpp_014: Passing Arrays and Vectors to Functions in C++ - Syntax and Examples

codeaddict — Sun, 9 Mar 2025 17:41:28 +0900

Introduction

In the previous lesson, we explored the differences between arrays and vectors in C++. Now, let’s dive deeper into how to pass arrays and vectors to functions in C++. Passing these data structures to functions is a common task in C++ programming, and understanding the syntax and usage is crucial for writing efficient and modular code.

In this lesson, we’ll cover:

The syntax for passing arrays and vectors to functions.
Example problems and solutions.

Passing Arrays to Functions

Syntax for Passing Arrays

When passing an array to a function, you pass a pointer to the first element of the array. The size of the array is often passed as a separate argument.

void functionName(T arr[], int size);

T is the data type of the array.
arr[] is the array passed to the function.
size is the number of elements in the array.

Example 1: Finding the Maximum Element in an Array

Problem Statement

Write a program that takes an array of integers as input, passes it to a function, and finds the maximum element in the array.

Solution

#include <iostream>
using namespace std;
// Function to find the maximum element in an array
int findMax(int arr[], int size) {
    int max = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}
int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int size = sizeof(arr) / sizeof(arr[0]);
    // Pass the array to the function
    int maxElement = findMax(arr, size);
    cout << "The maximum element in the array is: " << maxElement << endl;
    return 0;
}

Output

The maximum element in the array is: 50

Passing Vectors to Functions

Syntax for Passing Vectors

Vectors are passed to functions by reference or by value. Passing by reference is more efficient for large vectors.

void functionName(vector<T> &vec);

T is the data type of the vector.
&vec is the vector passed by reference, meaning that any modifications in the function will directly affect the original vector.
Note:
For a deeper understanding of how references work (indicated by &), please refer to the additional example at the end of this tutorial.

Example 2: Calculating the Sum of Elements in a Vector

Problem Statement

Write a program that takes a vector of integers as input, passes it to a function, and calculates the sum of its elements.

Solution

#include <iostream>
#include <vector>
using namespace std;
// Function to calculate the sum of elements in a vector
int calculateSum(vector<int> &vec) {
    int sum = 0;
    for (int i = 0; i < vec.size(); i++) {
        sum += vec[i];
    }
    return sum;
}
int main() {
    vector<int> vec = {1, 2, 3, 4, 5};
    // Pass the vector to the function
    int sum = calculateSum(vec);
    cout << "The sum of elements in the vector is: " << sum << endl;
    return 0;
}

Output

The sum of elements in the vector is: 15

Note about size():

The size() function is a member of the vector class, and it returns the number of elements in the vector.
Important: Since vectors are dynamic, they don’t require manual size calculations like arrays. You can simply use vec.size() to get the number of elements.

Comparing Array and Vector Usage

Example 3: Modifying Elements in an Array and Vector

Problem Statement

Write a program that demonstrates how to modify elements in an array and a vector by passing them to functions.

Solution

#include <iostream>
#include <vector>
using namespace std;

// Function to modify an array
void modifyArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        arr[i] *= 2; // Double each element
    }
}
// Function to modify a vector
void modifyVector(vector<int> &vec) {
    for (int i = 0; i < vec.size(); i++) {
        vec[i] *= 2; // Double each element
    }
}
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    vector<int> vec = {1, 2, 3, 4, 5};
    // Pass the array and vector to functions
    modifyArray(arr, size);
    modifyVector(vec);
    cout << "Modified array: ";
    for (int i = 0; i < size; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    cout << "Modified vector: ";
    for (int i = 0; i < vec.size(); i++) {
        cout << vec[i] << " ";
    }
    cout << endl;
    return 0;
}

Output

Modified array: 2 4 6 8 10  
Modified vector: 2 4 6 8 10

_________________________________________________________________

Additional Note on & (Reference) in Vectors and Arrays

In C++, when we pass a vector or array to a function using &, we are passing it by reference. This means that the function works directly with the original vector or array, not a copy. Any changes made to the vector or array inside the function will directly affect the original vector or array outside the function. This is more efficient for large vectors because it avoids the overhead of copying the entire data structure.

Example of Passing by Reference:
void modifyVector(vector<int> &vec)
The & symbol indicates that the vector is being passed by reference. This allows the function to directly modify the contents of the vector.

Understanding References with & (simple example for beginners)

To understand the concept of passing by reference using &, consider this simple example:

#include <iostream>
using namespace std;

void modifyValue(int &x) {  // Passed by reference
    x = 20;  // Modify the original value
}
int main() {
    int num = 10;
    modifyValue(num);  // Pass 'num' by reference
    cout << "Modified value: " << num << endl;  // Output will be 20
    return 0;
}

Output:

Modified value: 20

Explanation:

In this example, modifyValue takes an integer parameter x passed by reference. This means that when x is modified inside the function, the original num variable is also modified.
So, the value of num changes to 20 inside the function, and the modified value is reflected when we print it in main().

Example 2: Passing by Value (without &)

#include <iostream>
using namespace std;

void modifyValue(int x) {  // Passed by value
    x = 20;  // Modify the local copy of the value
}

int main() {
    int num = 10;
    modifyValue(num);  // Pass 'num' by value
    cout << "Modified value: " << num << endl;  // Output will be 10
    return 0;
}

Output:

Modified value: 10

Explanation:

In this case, modifyValue takes an integer parameter x passed by value. This means that a copy of num is passed to the function, and any changes made to x inside the function do not affect the original num in main().
So, even though we modify x inside the function, the value of num remains unchanged and is still 10 when printed.

Summary:

Passing by Reference (&) allows the function to modify the original variable, so changes are reflected outside the function.
Passing by Value creates a copy of the variable, so modifications inside the function do not affect the original variable.

_________________________________________________________________

Python Intermediate_006: Decorators in Python

codeaddict — Tue, 4 Mar 2025 22:34:04 +0900

Decorators in Python are a powerful feature that allows you to modify or extend the behavior of functions without changing their actual code. In this blog post, we’ll explore two examples: a basic decorator to add behavior around a function and a more practical one to simulate access control. Let’s get started!

1. Basic Decorator Example

Here’s a simple decorator that adds some behavior before and after a function call:

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("1. Before function call")  
        result = func(*args, **kwargs)  
        print("2. After function call") 
        return result  
    return wrapper  

@my_decorator
def add(x, y):
    print("   → Inside function: Adding numbers")  # Step 3.1
    return x + y  

print("START")  
result = add(3, 4)  
print(f"RESULT: {result}")  
print("END")

Output:

START
1. Before function call
   → Inside function: Adding numbers
2. After function call
RESULT: 7
END

Order of Execution

Let’s break down the order in which the code is executed:

2. Practical Example: Access Control Decorator

Now, let’s create a more useful decorator that simulates restricting access to a function based on a condition (e.g., user authentication). This is a simplified version of what you might see in web frameworks like Flask.

def require_auth(func):
    def wrapper(user, *args, **kwargs):
        # Simulate checking if the user is authenticated
        if user.get("is_authenticated", False):  # Check if user is authenticated
            print("1. Access granted!")
            return func(user, *args, **kwargs)   # Call the original function
        else:
            print("1. Access denied: Please log in.")
            return None                          # Return None if access is denied
    return wrapper

@require_auth
def view_profile(user):
    print("   → Inside function: Fetching profile data")
    return f"Profile: {user['username']}"

# Test with an unauthenticated user
user1 = {"username": "Alice", "is_authenticated": False}
print("START")
result = view_profile(user1)
print(f"RESULT: {result}")
print("END")

# Test with an authenticated user
user2 = {"username": "Bob", "is_authenticated": True}
print("\nSTART")
result = view_profile(user2)
print(f"RESULT: {result}")
print("END")

Output:

START
1. Access denied: Please log in.
RESULT: None
END

START
1. Access granted!
   → Inside function: Fetching profile data
RESULT: Profile: Bob
END

Order of Execution (for user2)

Step 1: @require_auth — The view_profile function is wrapped by require_auth.
Step 2: print(“START”) — Prints “START” before calling the function.
Step 3: result = view_profile(user2) → calls wrapper — The decorator runs before view_profile().
Step 4: if user.get(“is_authenticated”, False) — Checks if the user is authenticated (True for user2).
Step 5: print(“1. Access granted!”) — Prints “Access granted!” since the condition is met.
Step 6: func(user, *args, **kwargs) → Calls view_profile — The original function view_profile is called with user2.
Step 7: print(“ → Inside function: Fetching profile data”) — Prints inside view_profile().
Step 8: return f”Profile: {user[‘username’]}” — Returns “Profile: Bob” to wrapper.
Step 9: return func(…) — wrapper returns the result to result.
Step 10: print(f”RESULT: {result}”) — Prints “RESULT: Profile: Bob”.
Step 11: print(“END”) — Prints “END”.

For user1: The decorator stops at step 4, prints “Access denied: Please log in.”, and returns None.

Decorators are incredibly versatile! The access control example shows how they’re used in frameworks to manage permissions. Try tweaking the require_auth decorator to log failed attempts or add more conditions!

DjangoAPI_001_Docker Setup with GitHub and Docker Hub

codeaddict — Sun, 2 Mar 2025 18:32:45 +0900

Overview and Summary of Steps

This tutorial guides you through setting up a Django project for a REST API using Docker and Docker Compose, linking it to GitHub for version control, and pushing it to Docker Hub securely — all without needing Python

Summary of Steps:

Start a Project on GitHub: Create and clone a repository.
Add Docker Hub Secrets in GitHub: Store Docker Hub credentials securely.
Set Up the Project Locally: Add Docker files and create a Django app in a container.
Run the Server: Launch the app with Docker Compose.
Push to Docker Hub: Share your Docker image online.

Let’s get started!

Step 1: Start a Project on GitHub for Our Apps

1.1 Create a GitHub Repository

Go to GitHub and log in.
Click + New Repository.
Name it (e.g., my-django-project).
Check Add a README file.
Select Python under Add .gitignore.
Click Create Repository.

1.2 Clone It Locally

Copy the SSH URL (e.g., git@github.com:your-username/my-django-project.git).
Open your terminal.
Navigate to your folder:

cd /path/to/your/folder

4. Clone it:

git clone git@github.com:your-username/my-django-project.git

5. Enter the folder:

cd my-django-project

Step 2: Set Up Docker Hub Authentication

To push Docker images, we need authentication. Instead of using passwords (which are insecure), we use Access Tokens.

2.1 What is a Credential?

A credential is proof of identity (like a username and password or an API token).

Docker Hub requires authentication to push/pull images.
Instead of a password, we use an Access Token.
This is safer, as we can revoke the token if needed.

2.2 Generate a Docker Hub Access Token

Go to Docker Hub.
Log in to your account.
Go to your Docker Hub account settings (top-right corner > “Account Settings”).
Navigate to “Personal access tokens” and click “Generate new token.”
Give it a name (e.g., my-django-project), set permissions (e.g., “Read & Write”), Click Generate and copy the token.
Copy the token immediately (you will not see it again).

Why do we need an Access Token?

Security: Safer than passwords.
Automation: Allows scripts and CI/CD pipelines to authenticate.
Revocability: You can delete a token without affecting your account.

Step 3: Store Docker Credentials in GitHub Secrets

Now, we will store our credentials in GitHub Secrets for secure access in CI/CD pipelines.

3.1 Add Docker Hub Credentials to GitHub

Go to your GitHub repository.
Click Settings → Secrets and variables → Actions.
Click New repository secret.
Add the first secret:

Name: DOCKERHUB_USERNAME
Value: (Your Docker Hub username)
Click Add Secret.

5. Add the second secret:

Name: DOCKERHUB_TOKEN
Value: (Paste the Docker Hub Access Token you copied earlier)
Click Add Secret.

Step 4: Make a Project on Our Machine by Adding Dockerfile, Docker Compose File, Requirements File, and Creating a Blank Django App Using Django CLI

4.1 Ensure Docker is Running

Install Docker Desktop.
Start Docker Desktop.

4.2 Create a requirements.txt File

In my-django-project, create requirements.txt and save it.

django==4.2

Why? Lists packages for Docker to install.

4.3 Create a Dockerfile

Create Dockerfile in my-django-project.

FROM python:3.9
# Starts with Python 3.9 from Docker Hub.
# Options: python:3.10, python:3.9-slim, python:3.9-alpine

WORKDIR /app
# Sets "/app" as the working folder.
# Options: WORKDIR /myproject, omit it

COPY requirements.txt .
# Copies requirements.txt to /app.
# Options: COPY ./requirements.txt /app/req.txt

RUN pip install --no-cache-dir -r requirements.txt
# Installs Django, keeps image small.
# Options: RUN pip install -r requirements.txt

COPY . .
# Copies all project files to /app.
# Options: COPY ./app /app

EXPOSE 8000
# Opens port 8000.
# Options: EXPOSE 5000

Why? Builds the container for your app.

4.4 Create a docker-compose.yml File with Detailed Explanations

Create docker-compose.yml in my-django-project.

version: '3.8'
# Sets Compose version.
# Options: '3.9', '2'

services:
  app:
    # Service name.
    # Options: web, django

    build: .
    # Builds from Dockerfile.
    # Options: build: ./docker, image: my-django-app

    ports:
      - "8000:8000"
    # Maps port 8000.
    # Options: "5000:5000", "8080:8000"

    volumes:
      - .:/app
    # Syncs local folder with /app.
    # Options: ./code:/app, omit it

    command: python manage.py runserver 0.0.0.0:8000
    # Runs Django server.
    # Options: command: bash

Why? Manages your app’s container.

4.5 Create a .dockerignore File

Create .dockerignore in my-django-project.

__pycache__
*.pyc
.git
.gitignore

Why? Keeps container clean.

Step 5: Create a New Django Project Inside the Container

Build the Docker Image
Run the following command to build the Docker image:

docker-compose build

2. Create a New Django Project
Use docker-compose run to create a new Django project inside the container:

docker-compose run - rm app sh -c "django-admin startproject app ."

This creates a new Django project named app in the /app directory inside the container, which is synced with your local project folder.

3. Verify the Project Structure
After running the command, you should see the following files in your local project folder:

my-django-app/
├── app/
│ ├── __init__.py
│ ├── asgi.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
├── manage.py
├── requirements.txt
├── Dockerfile
├── docker-compose.yml
└── .dockerignore

Step 6: Run the Django Development Server

Start the Container
Run the following command to start the container:

docker-compose up

2. Access Your Django App
Open your browser and go to http://localhost:8000. You should see the Django welcome page.

cpp_014: Exploring Different Types of For Loops in C++ — Range-Based and Reference-Based Loops

codeaddict — Sat, 1 Mar 2025 22:51:48 +0900

Introduction

In one of the previous lessons (cpp_008: for Loops in C++), we covered the basics of for loops, including their syntax and common use cases.

In this lesson, we’ll explore different types of for loops in C++, specifically focusing on range-based for loops and reference-based for loops. These loops provide cleaner, more efficient, and safer ways to iterate over collections like arrays, vectors, and other containers. We’ll explain why and when to use these loops, along with examples and outputs to help beginners understand these concepts easily.

If you’re not familiar with vectors in C++, I recommend checking out our previous lessons on arrays and vectors before diving into this post.

Range-Based For Loops

General Rule and Syntax

Range-based for loops, simplify iterating over collections like arrays, vectors, and other containers. The syntax is:

for (type variable : collection) {
    // Code block to execute
}

Here, type is the data type of the elements in the collection, variable is the loop variable, and collection is the container (e.g., array, vector).

Explanation of the Syntax

Automatic Iteration:
The loop automatically iterates over each element in the collection, eliminating the need for manual indexing.
Read-Only by Default:
By default, the loop variable (variable) is a copy of the element in the collection. This means modifications to variable do not affect the original collection.
Cleaner Code:
Range-based loops reduce boilerplate code, making it easier to read and maintain.

Example 1: Range-Based Loop with Vectors

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> vec = {1, 2, 3, 4, 5};
    cout << "Vector elements: ";
    for (int num : vec) {
        cout << num << " ";
    }
    return 0;
}

Output:

Vector elements: 1 2 3 4 5

Explanation:

The loop iterates over each element in the vector vec.
The variable num is a copy of the current element, so changes to num do not affect vec.

Reference-Based For Loops

General Rule and Syntax

When you want to modify the elements of a collection during iteration, you can use a reference-based for loop. The syntax is:

for (type& variable : collection) {
    // Code block to execute
}

Here, type& indicates that variable is a reference to the elements in the collection.

Explanation of the Syntax

Reference Mechanism:
The loop variable (variable) is a reference to the actual element in the collection, not a copy.
Modifications Affect the Original Collection:
Changes made to variable inside the loop will modify the original collection.
Efficiency:
Using references avoids copying elements, which is especially beneficial for large collections or complex objects.

Example 2: Reference-Based Loop with Vectors

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> vec = {1, 2, 3, 4, 5};
    cout << "Original vector: ";
    for (int num : vec) {
        cout << num << " ";
    }
    cout << endl;
    // Modify the vector using a reference-based loop
    for (int& num : vec) {
        num *= 2; // Double each element
    }
    cout << "Modified vector: ";
    for (int num : vec) {
        cout << num << " ";
    }
    return 0;
}

Output:

Original vector: 1 2 3 4 5  
Modified vector: 2 4 6 8 10

Explanation:

The first loop prints the original vector.
The second loop uses a reference (int& num) to double each element in the vector.
The changes are reflected in the original vector.

Const Reference-Based For Loops

General Rule and Syntax

When you want to iterate over a collection without modifying its elements, you can use a const reference-based for loop. The syntax is:

for (const type& variable : collection) {
    // Code block to execute
}

Here, const type& ensures that variable is a read-only reference to the elements in the collection.

Explanation of the Syntax

Read-Only Access:
The loop variable (variable) cannot be modified, ensuring the collection remains unchanged.
Efficiency:
Using const references avoids copying elements while preventing accidental modifications.
Safety:
This approach is ideal for scenarios where you need to ensure data integrity.

Example 3: Const Reference-Based Loop with Vectors

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> vec = {1, 2, 3, 4, 5};
    cout << "Vector elements (read-only): ";
    for (const int& num : vec) {
        cout << num << " ";
    }
    return 0;
}

Output:

Vector elements (read-only): 1 2 3 4 5

Explanation:

The loop iterates over the vector using a const reference.
The elements cannot be modified inside the loop, ensuring the vector remains unchanged.

When to Use Each Type of Loop

Key Takeaways

Range-Based Loops: Simplify iteration over collections but work with copies of elements by default.
Reference-Based Loops: Allow modification of the original collection and avoid copying elements.
Const Reference-Based Loops: Provide efficient, read-only access to collections.

By understanding these different types of for loops, you can write cleaner, more efficient, and safer C++ code.

cpp_013: Arrays vs. Vectors in C++ - Understanding the Differences with Examples

codeaddict — Wed, 26 Feb 2025 21:19:36 +0900

Introduction

In C++, both arrays and vectors allow us to store multiple values in a structured format. However, they have fundamental differences in memory management, flexibility, and ease of use. This lesson will compare C++ arrays and vectors, highlight their key differences, and provide two example problems demonstrating when to use each.

Comparing the Syntax of Arrays and Vectors

Here, T is the data type (e.g., int, double, char), and N is the number of elements.

Key Differences Between Arrays and Vectors

Example 1: Finding the Sum of Elements

Problem Statement:
Write a program that takes N numbers as input, stores them in both an array and a vector, and computes the sum of elements.

✅ Solution Using an Array

#include <iostream>
using namespace std;

int main() {
    int N;
    cout << "Enter number of elements: ";
    cin >> N;
    
    int arr[N]; // Fixed-size array
    cout << "Enter " << N << " numbers: ";
    for(int i = 0; i < N; i++) {
        cin >> arr[i];
    }
    int sum = 0;
    for(int i = 0; i < N; i++) {
        sum += arr[i];
    }
    cout << "Sum using array: " << sum << endl;
    return 0;
}

Code Explanation:

int arr[N]; → Declares a fixed-size array.
cin >> arr[i]; → Reads N elements into the array.
sum += arr[i]; → Iterates through the array to compute the sum.

✅ Solution Using a Vector (Fixed-Size Approach)

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int N;
    int sum = 0;

    cout << "Enter number N: ";
    cin >> N;

    vector<int> myvector(N); // Declare a vector with N elements

    for (int i = 0; i < N; i++) {
        cout << "Enter element " << i << " out of " << N << ": ";
        cin >> myvector[i];
        sum += myvector[i]; // Compute the sum
    }

    cout << "Sum of vector is " << sum << endl;
    return 0;
}

Code Explanation:

vector<int> myvector(N); → Declares a vector with a fixed size of N.
cin >> myvector[i]; → Reads N elements dynamically.
sum += myvector[i]; → Iterates through the vector to compute the sum.

✅ Advantages:

✔ Simple and easy to understand
✔ No need for push_back() since size is fixed

❌ Disadvantages:

✘ Requires N to be known beforehand
✘ If N is too large, unnecessary memory is allocated

✅ Solution Using a Vector (Dynamic Approach)

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int N;
    int sum = 0;
    vector<int> myvector; // Declare an empty vector

    cout << "Enter number N: ";
    cin >> N;

    for (int i = 0; i < N; i++) {
        int value;
        cout << "Enter element " << i << " out of " << N << ": ";
        cin >> value;
        myvector.push_back(value); // Dynamically add elements
        sum += value;
    }

    cout << "Sum of vector is " << sum << endl;
    return 0;
}

Code Explanation:

vector<int> myvector; → Declares an empty vector.
myvector.push_back(value); → Dynamically adds elements to the vector.
sum += value; → Computes the sum during input.

✅ Advantages:

✔ Can handle unknown or varying N
✔ More memory efficient if N changes frequently

❌ Disadvantages:

✘ push_back() can be slower due to memory reallocation
✘ Uses more memory in some cases due to dynamic resizing

Output Example

Enter number N: 5  
Enter element 0 out of 5: 2  
Enter element 1 out of 5: 4  
Enter element 2 out of 5: 6  
Enter element 3 out of 5: 8  
Enter element 4 out of 5: 10  
Sum of vector is 30

cpp_012: Introduction to Vectors in C++

codeaddict — Mon, 17 Feb 2025 23:42:51 +0900

Vectors in C++ provide a more flexible alternative to arrays. They are part of the Standard Template Library (STL) and offer dynamic resizing, built-in functions, and better memory management. In this lesson, we’ll explore what vectors are, how they differ from arrays, and compare them to Python lists.

1. What is a Vector?

A vector is a dynamic array that automatically resizes as elements are added or removed. Unlike arrays, which have a fixed size, vectors grow and shrink as needed.

To use vectors in C++, you must include the <vector> header:

#include <vector>

Key Differences Between Vectors and Arrays

2. Declaring and Initializing Vectors

Vectors are defined using the std::vector keyword.

Basic Syntax

#include <iostream>
#include <vector>  // Include the vector library

using namespace std;

int main() {
    vector<int> numbers; // Declaring an empty vector
    vector<int> predefined = {10, 20, 30, 40}; // Declaring and initializing

    cout << "First element: " << predefined[0] << endl; // Accessing elements
}

Output:

First element: 10

3. Adding and Removing Elements

Vectors support dynamic modification using functions like .push_back() and .pop_back().

#include <iostream>
#include <vector>

using namespace std;

int main() {
    vector<int> numbers;

    numbers.push_back(10); // Adds 10 to the vector
    numbers.push_back(20); // Adds 20 to the vector
    numbers.push_back(30);

    cout << "Vector size: " << numbers.size() << endl; // Prints size

    numbers.pop_back(); // Removes the last element (30)
    cout << "New size after pop: " << numbers.size() << endl;
}

Output:

Vector size: 3  
New size after pop: 2

4. Iterating Over a Vector

Vectors can be accessed using loops or iterators.

Using a for loop

#include <iostream>
#include <vector>

using namespace std;

int main() {
    vector<int> nums = {1, 2, 3, 4, 5};

    for (int i = 0; i < nums.size(); i++) {
        cout << nums[i] << " ";
    }
}

Output:

1 2 3 4 5

Using a for-each loop

#include <iostream>
#include <vector>

using namespace std;

int main() {
    vector<int> nums = {1, 2, 3, 4, 5};

    for (int num : nums) {
        cout << num << " ";
    }
}

Output:

1 2 3 4 5

5. Comparison with Python Lists

Vectors in C++ are similar to Python lists because they allow dynamic resizing.

Python List Example

numbers = [10, 20, 30]
numbers.append(40)  # Equivalent to push_back()
print(numbers)  # [10, 20, 30, 40]

numbers.pop()  # Equivalent to pop_back()
print(numbers)  # [10, 20, 30]

Output:

[10, 20, 30, 40]  
[10, 20, 30]

7. Two-Dimensional Vectors

Vectors can store other vectors, just like a 2D array.

#include <iostream>
#include <vector>

using namespace std;

int main() {
    vector<vector<int>> matrix = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    cout << "Element at (1,1): " << matrix[1][1] << endl;
}

Output:

Element at (1,1): 5

Conclusion

Vectors are a powerful alternative to arrays in C++. They provide dynamic resizing, built-in functions, and flexibility, making them a preferred choice for many applications. Unlike arrays, vectors manage memory automatically and prevent overflow issues.

Key Takeaways

✅ Use vectors when you need a dynamic data structure.
✅ Arrays are faster but require manual memory management.
✅ Vectors in C++ work similarly to lists in Python.

PyTorch_002_Implementing a Graph Convolutional Network (GCN) Layer

codeaddict — Mon, 17 Feb 2025 16:54:32 +0900

In the previous lesson, we introduced the mathematical foundation of Graph Convolutional Networks (GCNs). You can find the explanation of the GCN formula in the following link: [link below].

https://medium.com/@staytechrich/graph-convolutional-networks-gcn-001-understanding-the-gcn-formula-step-by-step-a5e248c91ce0

Now, we will implement a GCN model in PyTorch, applying the concepts we learned. We will:
✅ Compute the degree matrix D.
✅ Compute the normalized adjacency matrix A-hat.
✅ Implement a GCN layer.
✅ Build a simple GCN model with two layers.

The core operation in GCNs follows this formula:

where:

A-hat (A^) is the normalized adjacency matrix.
X is the input feature matrix.
W is the learnable weight matrix.
H is the output after applying the graph convolution operation.
σ(sigma) is the activation function (e.g., ReLU).

Let’s implement this step by step:

import torch
import torch.nn.functional as F

def compute_degree_matrix(A):
    """Computes the degree matrix D from adjacency matrix A."""
    degrees = torch.sum(A, dim=1)
    D = torch.diag(degrees)
    return D

def normalize_adjacency(A):
    """Computes the normalized adjacency matrix A_hat = D^(-1/2) * A * D^(-1/2)."""
    D = compute_degree_matrix(A)
    D_inv_sqrt = torch.diag(torch.pow(torch.diag(D), -0.5))
    A_hat = D_inv_sqrt @ A @ D_inv_sqrt
    return A_hat

A. Computing the Degree Matrix (D)

The degree matrix (D) is a diagonal matrix where each diagonal element represents the sum of connections (or edges) for each node in the adjacency matrix.

Mathematically, if A is the adjacency matrix, the degree matrix D is computed as:

This means that each diagonal element of D contains the total number of edges connected to a given node.

Code Explanation:

torch.sum(A, dim=1): Summing along axis=1 (rows) gives the degree of each node.
torch.diag(degrees): Converts this degree vector into a diagonal matrix.

B. Computing the Normalized Adjacency Matrix (A^)

To stabilize training and ensure proper feature propagation, we normalize the adjacency matrix A. The normalized adjacency matrix A^ is computed as:

This normalization ensures that information is distributed more evenly across nodes.

class GCNLayer(torch.nn.Module):
    def __init__(self, in_features, out_features):
        super(GCNLayer, self).__init__()
        self.W = torch.nn.Parameter(torch.randn(in_features, out_features))  # Learnable weights

    def forward(self, A, X):
        A_hat = normalize_adjacency(A)  # Compute A_hat
        H = A_hat @ X @ self.W  # Graph convolution operation
        return F.relu(H)  # Apply ReLU activation

Code Explanation:

Define a weight matrix self.W that will be learned during training.
Compute the normalized adjacency matrix A_hat using the function we defined earlier.
Multiply A_hat @ X @ W to perform the graph convolution operation.
Apply ReLU activation function to introduce non-linearity.

2. Defining the GCN Model

A GCN model consists of multiple layers stacked on top of each other. Each layer extracts higher-level node representations.

Here, we define a two-layer GCN:

The first layer transforms input features into a hidden representation.
The second layer maps hidden representations to output features.

class GCN(torch.nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(GCN, self).__init__()
        self.gcn1 = GCNLayer(input_dim, hidden_dim)
        self.gcn2 = GCNLayer(hidden_dim, output_dim)

    def forward(self, A, X):
        H1 = self.gcn1(A, X)  # First GCN layer
        H2 = self.gcn2(A, H1)  # Second GCN layer
        return H2

Explanation:

First layer (gcn1) maps input features to a hidden dimension.
Second layer (gcn2) maps hidden features to the final output.
Pass adjacency matrix A and features X through both layers.

3. Running the GCN Model

Let’s test our model with some sample data:

Example Graph:

Adjacency matrix (A) representing a simple 3-node graph.
Feature matrix (X) with two features per node.

# Example adjacency matrix (3 nodes)
A = torch.tensor([[1, 1, 0],
                  [1, 1, 1],
                  [0, 1, 1]], dtype=torch.float32)

# Example feature matrix (3 nodes, 2 features)
X = torch.tensor([[1, 2],
                  [3, 4],
                  [5, 6]], dtype=torch.float32)

# Define the model
gcn = GCN(input_dim=2, hidden_dim=4, output_dim=2)

# Forward pass
output = gcn(A, X)
print("Final GCN Output:\n", output)

6. Step-by-Step Execution

Let’s walk through what happens when we execute gcn(A, X):

Compute A^ (Normalized Adjacency Matrix)

Compute the degree matrix D.
Compute D^(-1/2).
Normalize A to get A^.

2. First GCN Layer (gcn1)

Compute H1 = ReLU(A^ X W1) where W1 is the weight matrix of the first layer.

3. Second GCN Layer (gcn2)

Compute H2 = ReLU(A^ H1 W2) where W2 is the weight matrix of the second layer.

4. Final Output

H2 is returned as the final node representations.

Conclusion

In this lesson, we implemented a simple Graph Convolutional Network (GCN) in PyTorch. We followed the mathematical formula introduced in the previous lesson and broke it down into:
✔️ Computing the degree matrix D.
✔️ Computing the normalized adjacency matrix A-hat(A^).
✔️ Implementing a GCN layer.
✔️ Defining a two-layer GCN model.

In the next lesson, we will train this model on real graph data!

Graph_Convolutional_Networks (GCN)_001 _ Understanding the GCN Formula Step by Step

codeaddict — Mon, 17 Feb 2025 14:38:47 +0900

Introduction

In this post, we will break down the fundamental Graph Convolutional Network (GCN) formula with a simple example. We will walk through each component, including the adjacency matrix, degree matrix, normalization, and feature transformations. By the end of this lesson, you’ll have a clear understanding of the basic mathematical operations behind GCNs.

In a Graph Convolutional Network (GCN), the key transformation is given by the following formula:

Now, let's go step by step to understand how each part of this formula works in practice.

Step 1: Understanding the Graph Structure

Consider a simple graph with three nodes:

   (1) -- (2)
     \    /
      \  /
       (3)

The adjacency matrix (A) represents the connections between nodes:

The rows and columns correspond to nodes.
A value of 1 indicates a connection between nodes, while 0 means no direct connection.

Step 2: Adding Self-Loops

We add self-loops to each node by introducing an identity matrix (I):

Now, each node is also connected to itself.

Step 3: Computing the Degree Matrix

The degree matrix (D’) is a diagonal matrix where each diagonal element represents the sum of connections for that node:

For our graph, each node is connected to two other nodes and also has a self-loop (since we added the identity matrix I). So, each node has a total of 3 connections.

Why are only diagonal elements nonzero?

The degree matrix is always diagonal because it only counts the number of edges per node — not their relationships with other nodes.
The off-diagonal elements are always zero because they do not represent any direct connection count, only the total degree of each node.
Row 1: Node 1 is connected to Node 2, Node 3, and itself → Total = 3
Row 2: Node 2 is connected to Node 1, Node 3, and itself → Total = 3
Row 3: Node 3 is connected to Node 1, Node 2, and itself → Total = 3

Thus, the degree matrix is:

Each diagonal element (3) represents the sum of connections for that node, and of

Step 4: Normalizing the Adjacency Matrix

We compute the inverse square root of the degree matrix:

Step 5: Applying Features

At this stage, we introduce the feature matrix X, which represents the features of each node in our graph.

What is the feature matrix X?

Each row in X corresponds to a node in our graph.
Each column in X represents a feature associated with the node.
The values in X are imaginary/random for this example and do not represent real-world data. They are just chosen to make the calculations clear.

Assume we have 3 nodes, and each node has 2 features (e.g., some numerical properties like “height” and “weight” in a social network or “temperature” and “humidity” in a sensor network).

We define our feature matrix X as follows:

Here’s what each value represents:

Node 1: Feature 1 = 1, Feature 2 = 2
Node 2: Feature 1 = 3, Feature 2 = 4
Node 3: Feature 1 = 5, Feature 2 = 6

Important Notes:

These values are arbitrary and just for illustration. In real applications, these features could represent anything from user preferences in a social network to pixel values in an image.
The number of columns in X (here, 2) represents the input feature dimension — it defines how many numerical properties each node has.

Now that we have our feature matrix, the next step is to apply the graph convolutional operation using weights.

Step 6: Multiplying with A^ (Normalized Adjacency Matrix)

Now that we have our feature matrix X, the next step is to perform the graph convolution operation by multiplying X with the normalized adjacency matrix A^(A- hat).

What is A^?

A- hat is a modified version of the adjacency matrix that includes self-loops as described in previous steps
It helps in aggregating information from each node’s neighbors including itself.
The purpose of multiplying with A-hat is to allow nodes to receive feature information from their neighbors.

For our example, the multiplication looks like this:

What does this multiplication do?

It aggregates features from neighboring nodes.
Since each node has 2 direct neighbors (plus itself), the sum results in (3,4) for each row.
This shows that every node’s updated feature is influenced by the sum of itself and its neighbors’ features.

Step 7: Applying the Weight Matrix W

Now, we introduce the weight matrix W, which is a trainable parameter in a GCN:

These numbers are random and do not come from real data. They are just used for illustration purposes.
In a real GCN, these numbers are initialized randomly and then updated during training using backpropagation.

What is the Weight Matrix W?

W is a matrix that transforms the feature representations of nodes.
It learns to extract meaningful patterns from node features over time.
Each element in W represents how important a particular input feature is in transforming node embeddings.
W is learned during training and helps in transforming the features into a new space.
The rows in W correspond to the input feature dimension (2 features per node in X).
The columns in W correspond to the new transformed feature dimension (which could be different).

How are the values in W selected in real applications?

Initially, they are set randomly (e.g., small random values close to zero).
As the model trains, an optimization algorithm (like Gradient Descent) adjusts these values to minimize the loss.
Over time, W learns to capture the important relationships between node features and their labels (or other predictive targets).

Step 8: Understanding the Final Transformed Features

At this point, each node’s features have been updated based on:

Its own features (from X)
The features of its neighbors (aggregated using A-hat)
The learned transformation (from W)

Key Takeaways

The graph convolution operation allows each node to gather information from its neighbors.
The weight matrix W helps the model learn patterns in the data.
The output matrix represents the new features for each node, which can now be used for classification, clustering, or further graph learning tasks.

Step 6: Applying the Activation Function

Conclusion: Summary of Graph Convolutional Operation

Start with the feature matrix X, where each row represents a node’s features.
Multiply X with the normalized adjacency matrix A-hat(A^), aggregating neighboring node information.
Multiply the result with a trainable weight matrix W to transform features.
(Optional) Apply an activation function like ReLU for non-linearity.
Use the new features for tasks like node classification or link prediction.

In this post, we broke down the GCN formula step by step, starting with the graph structure and progressing through normalization, feature transformation, and activation. In the next lesson, we will implement this mathematically defined GCN as a simple model in PyTorch (included in pytorch beginner catogory).

threading_001: Introduction to Python Threads

codeaddict — Sun, 9 Feb 2025 17:30:42 +0900

In this tutorial, we will explore the basics of threading in Python. We will break down simple examples using the threading module and progressively dive into more complex scenarios.

Overview

Threading allows concurrent execution of multiple tasks (or threads) within a program. Python’s built-in threading module makes it easy to handle threads and boost performance for I/O-bound tasks.

1. Simple Example: Running Multiple Threads

The example below shows how to create and run two threads concurrently:

import threading
import time

# Define a function to run in threads
def print_numbers():
    for i in range(5):
        print(f"Number: {i}")
        time.sleep(1)  # Simulate a time-consuming task
# Create two threads
thread1 = threading.Thread(target=print_numbers)
thread2 = threading.Thread(target=print_numbers)
# Start the threads
thread1.start()
thread2.start()
# Wait for both threads to finish
thread1.join()
thread2.join()
print("Both threads have finished execution.")

We define a function print_numbers() that prints numbers from 0 to 4 with a 1-second delay between prints.
We create two threads using threading.Thread and pass the target function.
The threads are started with start() and waited upon using join().

2. Example 2: Passing Arguments to Threads

Now, let’s modify the code to pass arguments to the thread functions:

import threading
import time

# Define a function with arguments
def print_numbers(name, count):
    for i in range(count):
        print(f"{name} - Number: {i}")
        time.sleep(1)
# Create threads with different arguments
thread1 = threading.Thread(target=print_numbers, args=("Thread1", 3))
thread2 = threading.Thread(target=print_numbers, args=("Thread2", 5))
# Start the threads
thread1.start()
thread2.start()
# Wait for both threads to finish
thread1.join()
thread2.join()
print("All threads have completed.")

Explanation:

The print_numbers function now takes two arguments: name and count.
We pass these arguments using the args parameter when creating the threads.
Each thread behaves independently, printing its own sequence of numbers.

3. Example: Inheriting from threading.Thread

Another approach is to create a custom class by inheriting from threading.Thread. Below is a simple example:

import threading
import time
from typing import Dict, List

class CustomThread(threading.Thread):
    thread_store: Dict[str, List[threading.Thread]] = {}
    def __init__(self, name: str, count: int):
        super().__init__()
        self.name = name
        self.count = count
    def run(self):
        """The entry point for the thread."""
        for i in range(self.count):
            print(f"{self.name} - Number: {i}")
            time.sleep(1)
# Create and start threads
thread1 = CustomThread("Thread1", 3)
thread2 = CustomThread("Thread2", 5)
thread1.start()
thread2.start()
# Wait for both threads to finish
thread1.join()
thread2.join()
print("Custom threads have completed.")

Explanation:

Class Definition: The CustomThread class inherits from threading.Thread.
Shared Resource: thread_store is a class-level dictionary for managing threads if needed in more complex cases.
Initialization: The __init__ method calls super().__init__() to ensure proper initialization of the thread.
Overriding run(): The run() method defines the code that will execute in the thread.
Creating and Starting Threads: We instantiate the custom threads and start them with start().
Joining Threads: join() ensures that the main program waits for both threads to complete.

cpp_012: Multidimensional Arrays in C++

codeaddict — Sat, 8 Feb 2025 15:09:29 +0900

Multidimensional arrays are an extension of one-dimensional arrays, allowing you to store data in a grid-like structure. They are particularly useful for representing matrices, tables, or any data that requires multiple dimensions. In this lesson, we’ll explore how to declare, initialize, and use multidimensional arrays in C++. We’ll also cover how to input data into arrays using cin and handle early loop exits.

1. What Are Multidimensional Arrays?

A multidimensional array is an array of arrays. For example, a 2D array can be thought of as a table with rows and columns, while a 3D array can be visualized as a cube with layers, rows, and columns.

2. Declaring and Initializing Multidimensional Arrays

To declare a 2D array in C++, use the following syntax:

data_type array_name[rows][columns];

Example:

int matrix[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

For a 3D array:

int cube[2][3][4] = {
    {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    },
    {
        {13, 14, 15, 16},
        {17, 18, 19, 20},
        {21, 22, 23, 24}
    }
};

3. Accessing Elements in Multidimensional Arrays

You can access elements using nested loops. For example, to print a 2D array:

#include <iostream>
using namespace std;

int main() {
    // Declaring and initializing a 2D array
    int matrix[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };

    // Loop to traverse the 2D array and print its elements
    for (int i = 0; i < 2; i++) {   // Loop through rows
        for (int j = 0; j < 3; j++) {  // Loop through columns
            cout << matrix[i][j] << " ";  // Print each element
        }
        cout << endl;  // Print a new line after each row
    }

    return 0;  // Return 0 to indicate successful execution
}

4. Inputting Data into Arrays Using cin

You can use cin to populate arrays with user input. Here’s how:

For a 1D Array:

int arr[5];
cout << "Enter 5 elements: ";
for (int i = 0; i < 5; i++) {
    cin >> arr[i];
}

Complete code:

#include<iostream>
using namespace std;

int main() {
    int arr[5];  // Declare an array of size 5

    // Input values into the array
    cout << "Enter 5 integers: ";
    for (int i = 0; i < 5; i++) {
        cin >> arr[i];  // Take input for each element of the array
    }

    // Output the elements of the array
    cout << "Array elements: ";
    for (int i = 0; i < 5; i++) {
        cout << arr[i] << " ";  // Print each element followed by a space
    }
    cout << endl;  // Print a new line after the array

    return 0;  // Return 0 to indicate successful execution
}

For a 2D Array:

int matrix[2][3];
cout << "Enter 6 elements (2 rows x 3 columns): ";
for (int i = 0; i < 2; i++) {
    for (int j = 0; j < 3; j++) {
        cin >> matrix[i][j];
    }
}

Complete code:

#include<iostream>
using namespace std;

int main() {
    // Declare a 2D array with 2 rows and 3 columns
    int matrix[2][3];

    // Input elements into the matrix
    cout << "Enter 6 elements (2 rows x 3 columns): ";
    for (int i = 0; i < 2; i++) {       // Loop through rows
        for (int j = 0; j < 3; j++) {   // Loop through columns
            cin >> matrix[i][j];  // Read input for each element
        }
    }

    // Output the elements of the matrix
    cout << "The matrix is:" << endl;
    for (int i = 0; i < 2; i++) {       // Loop through rows
        for (int j = 0; j < 3; j++) {   // Loop through columns
            cout << matrix[i][j] << " ";  // Print each element
        }
        cout << endl;  // Print a new line after each row
    }

    return 0;  // Return 0 to indicate successful execution
}

Python Intermediate_005: Type Hinting in Python

codeaddict — Sat, 8 Feb 2025 01:47:57 +0900

When writing Python code, you often need to make your code more readable and maintainable, especially for larger projects. This is where type hinting becomes essential. Type hints help you specify the expected types of variables, function arguments, and return values. Let’s explore how to use type hints effectively with simple examples.

Why Use Type Hints?

Type hints help:

Improve code readability.
Catch type-related errors during development.
Provide better autocompletion and type checking in IDEs.

Basic Type Hints

Here’s how to annotate variable types and function signatures:

# Variable type hints
name: str = "Alice"
age: int = 30
is_active: bool = True

# Function with type hints
def greet(name: str) -> str:
    return f"Hello, {name}!"
print(greet("Bob"))

Explanation:

name: str: Indicates that name is a string.
age: int: Indicates that age is an integer.
def greet(name: str) -> str: Specifies that the greet function takes a string argument and returns a string.

Type Hints with Collections

You can annotate lists, dictionaries, and other collections using the List and Dict types from the typing module.

from typing import List, Dict

# List of integers
numbers: List[int] = [1, 2, 3, 4]
# Dictionary with string keys and integer values
data: Dict[str, int] = {"apples": 5, "oranges": 3}
print(numbers)
print(data)

Explanation:

List[int]: Specifies that numbers is a list containing integers.
Dict[str, int]: Indicates that data is a dictionary with string keys and integer values.

Type Hints for Functions with Multiple Arguments

You can use type hints to specify types for multiple arguments.

from typing import List

def calculate_sum(numbers: List[int]) -> int:
    return sum(numbers)
result = calculate_sum([10, 20, 30])
print(f"Sum: {result}")

Explanation:

numbers: List[int]: The function expects a list of integers.
-> int: The function returns an integer.

Using Optional Types

Sometimes, a variable or function argument can be optional. Use Optional to indicate this.

from typing import Optional

def greet(name: Optional[str] = None) -> str:
    if name:
        return f"Hello, {name}!"
    return "Hello, Stranger!"
print(greet())
print(greet("Alice"))

Explanation:

Optional[str]: Indicates that name can be either a string or None.
The default value of None allows the argument to be optional.

Django REST Framework_004: erializers and Model-to-JSON Conversion

codeaddict — Thu, 6 Feb 2025 23:51:33 +0900

In this lesson, we will dive deeper into Django REST Framework (DRF) serializers, which are a crucial component for converting complex data types, such as Django models, into Python data types that can be easily rendered into JSON, XML, or other content types. We will also explore the important methods and concepts related to serializers, and how they fit into the broader context of building RESTful APIs with Django.

What is a Serializer?

A serializer in Django REST Framework is a component that allows you to convert complex data types (like Django models) into Python data types that can be easily rendered into JSON, XML, or other content types. Serializers also provide deserialization, allowing parsed data to be converted back into complex types after validating the incoming data.

In simpler terms, serializers help you:

Convert Django models to JSON: When you want to send data from your Django application to a client (e.g., a web browser or mobile app), serializers convert your Django model instances into JSON format.
Convert JSON to Django models: When you receive data from a client (e.g., a form submission), serializers validate the data and convert it back into a Django model instance.

Step 1: Setting Up Your Django Project

Before we dive into serializers, let’s ensure that your Django project is set up correctly.

Install Django and Django REST Framework:

pip install django djangorestframework

2. Create a Django Project:

django-admin startproject myproject cd myproject

3. Create a Django App:

python manage.py startapp myapp

4. Add rest_framework and myapp to INSTALLED_APPS:
In myproject/settings.py, add:

INSTALLED_APPS = [ … 'rest_framework', 'myapp', ]

Step 2: Creating a Model

Let’s create a simple Book model in myapp/models.py:

from django.db import models
class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=100)
    published_date = models.DateField()
    isbn = models.CharField(max_length=13, unique=True)
    def __str__(self):
        return self.title

5. Run Migrations:

python manage.py makemigrations 
python manage.py migrate

Step 3: Creating a Serializer

Serializers are defined in a serializers.py file within your app. Let's create a serializer for the Book model.

In myapp/serializers.py, create a BookSerializer:

from rest_framework import serializers
from .models import Book
class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'published_date', 'isbn']

Key Points About Serializers:

ModelSerializer: This is a shortcut for creating serializers that map closely to Django models. It automatically generates fields based on the model and provides default implementations for creating and updating instances.
fields: This attribute specifies which fields from the model should be included in the serialized output. You can also use __all__ to include all fields.
read_only_fields: You can specify fields that should be read-only (e.g., id).
extra_kwargs: This allows you to specify additional options for fields, such as making a field write-only or adding validation rules.

Step 4: Creating Views

Now that we have a serializer, let’s create views to handle API requests. We’ll use DRF’s generic views to simplify the process.

In myapp/views.py:

from rest_framework import generics
from .models import Book
from .serializers import BookSerializer

class BookListCreateView(generics.ListCreateAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
class BookDetailView(generics.RetrieveUpdateDestroyAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

Key Points About Views:

ListCreateAPIView: This view handles both listing all instances of a model and creating new instances.
RetrieveUpdateDestroyAPIView: This view handles retrieving, updating, and deleting a single instance of a model.
queryset: This specifies the set of objects that the view will operate on.
serializer_class: This specifies the serializer to use for converting the model instances to JSON and vice versa.

Step 5: Defining URLs

Next, we need to define the URLs for our API. In myapp/urls.py:

from django.urls import path
from .views import BookListCreateView, BookDetailView
urlpatterns = [
    path('books/', BookListCreateView.as_view(), name='book-list-create'),
    path('books/<int:pk>/', BookDetailView.as_view(), name='book-detail'),
]

Then, include these URLs in the project’s urls.py (in myproject/urls.py):

from django.contrib import admin
from django.urls import path, include
urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('myapp.urls')),
]

Step 6: Testing the API

Run the Development Server:

ython manage.py runserver

2. Access the API:

Go to http://127.0.0.1:8000/api/books/ to see the list of books or create a new one.
Go to http://127.0.0.1:8000/api/books/1/ to view, update, or delete a specific book.

3. Add Data via Django Admin:

from django.contrib import admin
from .models import Book

admin.site.register(Book)

Create a superuser:

python manage.py createsuperuser

Step 7: Testing with Postman or Curl

You can use tools like Postman or curl to test your API endpoints.

Create a Book:

curl -X POST -H “Content-Type: application/json” -d ‘{“title”: “1984”, “author”: “George Orwell”, “published_date”: “1949–06–08”, “isbn”: “9780451524935”}’ http://127.0.0.1:8000/api/books/

curl -X POST -H "Content-Type: application/json" -d '{"title": "1984", "author": "George Orwell", "published_date": "1949-06-08", "isbn": "9780451524935"}' http://127.0.0.1:8000/api/books/

2. Get All Books:

curl http://127.0.0.1:8000/api/books/

3. Get a Specific Book:

curl http://127.0.0.1:8000/api/books/1/

4. Update a Book:

curl -X PUT -H "Content-Type: application/json" -d '{"title": "1984", "author": "George Orwell", "published_date": "1949–06–08", "isbn": "9780451524935"}' http://127.0.0.1:8000/api/books/1/

5. Delete a Book:

curl -X DELETE http://127.0.0.1:8000/api/books/1/

Summary

In this lesson, we:

Created a Django model (Book).
Created a serializer (BookSerializer) to convert the model into JSON.
Created views to handle API requests (BookListCreateView and BookDetailView).
Defined URLs for the API.
Tested the API using the Django development server and tools like Postman or curl.

By following these steps, you now have a basic understanding of how serializers work in Django REST Framework and how they can be used to build RESTful APIs. In the next lesson, we will explore more advanced features of serializers, such as custom validation and nested serializers.

Django REST Framework_003: Visualizing Django Models with django-extensions

codeaddict — Sat, 1 Feb 2025 23:02:15 +0900

In Django projects, understanding the relationships between your models is essential for designing and maintaining your application. While Django’s ORM makes it easy to define models and their relationships, visualizing these relationships can help you better understand your database schema.

In this lesson, we will:

Use django-extensions to generate a .dot file for your Django models.
Visualize the .dot file using the Graphviz Online Editor.
Automatically generate a diagram from the .dot file.

Why Use Graphviz Online?

Graphviz Online (https://dreampuf.github.io/GraphvizOnline) is a web-based tool that allows you to visualize .dot files without installing any additional software. It’s perfect for quickly generating and sharing diagrams of your Django models.

Step 1: Install Required Packages

To generate a .dot file, you’ll need the django-extensions library.

Install django-extensions

Run the following command in your terminal:

pip install django-extensions

Step 2: Add django-extensions to Your Django Project

Open your Django project’s settings.py file.
Add 'django_extensions' to the INSTALLED_APPS list:

INSTALLED_APPS = [ … 'django_extensions', … ]

Step 3: Generate the .dot File

Now that django-extensions is installed, you can use the graph_models command to generate a .dot file for your Django models.

Generate a .dot File for All Models

To generate a .dot file for all models in your project, run:

python manage.py graph_models -a > models.dot

-a: Include all models in your project.
> models.dot: Save the output to a file named models.dot.

Generate a .dot File for a Specific App

If you only want to generate a .dot file for a specific app (e.g., api), run:

python manage.py graph_models api > api_models.dot

Step 4: Visualize the .dot File Using Graphviz Online

Open the Graphviz Online Editor in your browser: https://dreampuf.github.io/GraphvizOnline.
Open the .dot file you generated (e.g., models.dot) in a text editor (like Notepad, VS Code, or any other editor).
Copy the entire content of the .dot file.
Paste the content into the Graphviz Online Editor.
The diagram will be automatically generated and displayed in the editor.

Step 5: Interpret the Diagram

The generated diagram will show:

Models: Each box represents a Django model.
Fields: The fields of each model are listed inside the box.
Relationships: Arrows between boxes represent relationships like ForeignKey, OneToOneField, and ManyToManyField.

For example:

A solid arrow with a single head represents a ForeignKey relationship.
A solid arrow with two heads represents a ManyToManyField relationship.

Step 6: Customize the Diagram (Optional)

If you want to customize the diagram, you can edit the .dot file before pasting it into the Graphviz Online Editor. For example:

Change Colors: Add color attributes to the nodes (models) or edges (relationships).
Group Models: Use subgraphs to group models by app or functionality.

Here’s an example of a customized .dot file:

digraph G {
    node [shape=box, style=filled, color=lightblue];
    edge [color=gray];

    User [label="User\nusername\nemail"];
    Profile [label="Profile\nbio\nimage"];
    Post [label="Post\ntitle\ncontent"];

    User -> Profile [label="OneToOne"];
    User -> Post [label="ForeignKey"];
}

Common Issues and Troubleshooting

No Models Found:

Make sure the app name you provided in the command is correct.
Ensure the app is included in INSTALLED_APPS.

2. Graphviz Online Not Rendering:

Check the .dot file for syntax errors.
Ensure the file is properly formatted and contains valid Graphviz code.

3. Output File Not Generated:

Check the command syntax and ensure the output file path is valid.

cpp_011: Understanding the sizeof Operator in C++

codeaddict — Sat, 1 Feb 2025 15:07:12 +0900

In this lesson, we’ll explore the sizeof operator in C++. This operator is used to determine the size (in bytes) of a variable, data type, or entire array. It's important to understand that sizeof does not directly give the number of elements in an array but rather the total memory size. To calculate the number of elements, you need to divide the total size of the array by the size of a single element. Let’s dive into the syntax and an example to understand how it works.

1. Syntax of sizeof Operator

The sizeof operator can be used in two ways:

For Variables or Data Types:

sizeof(variableName);
sizeof(dataType);

2. For Arrays:

sizeof(arrayName) / sizeof(arrayName[0]);

sizeof(arrayName): Returns the total size of the array in bytes.
sizeof(arrayName[0]): Returns the size of a single element in the array.

2. Example: Using sizeof with Arrays

Let’s write a program to calculate the size of an array and the number of elements it contains.

Problem Statement:

Write a C++ program to:

Declare an array of integers.
Use the sizeof operator to determine the total size of the array and the size of a single element.
Calculate and display the number of elements in the array.

Solution Code

#include <iostream>
using namespace std;

int main() {
    int numbers[] = {10, 20, 30, 40, 50};
    // Calculate the total size of the array in bytes
    int totalSize = sizeof(numbers);
    // Calculate the size of a single element in bytes
    int elementSize = sizeof(numbers[0]);
    // Calculate the number of elements in the array
    int numElements = totalSize / elementSize;
    cout << "Total size of the array: " << totalSize << " bytes" << endl;
    cout << "Size of a single element: " << elementSize << " bytes" << endl;
    cout << "Number of elements in the array: " << numElements << endl;
    return 0;
}

Explanation

Total Size of the Array:

sizeof(numbers) returns the total size of the array in bytes. For example, if the array has 5 integers and each integer occupies 4 bytes, the total size will be 20 bytes.

2. Size of a Single Element:

sizeof(numbers[0]) returns the size of the first element in the array. For an int, this is typically 4 bytes.

3. Number of Elements:

Dividing the total size of the array by the size of a single element gives the number of elements in the array.

Output

Total size of the array: 20 bytes  
Size of a single element: 4 bytes  
Number of elements in the array: 5

Key Takeaway

The sizeof operator is a powerful tool for understanding memory allocation and calculating the size of arrays or variables. Use it to make your programs more dynamic and efficient!

CSS_004_Grouping Selectors in CSS

codeaddict — Sat, 1 Feb 2025 13:52:54 +0900

In this blog post, we’ll explore grouping in CSS, a powerful technique to apply the same styles to multiple selectors like headers, classes, and IDs. Grouping helps reduce redundancy and keeps your CSS clean. We’ll also learn how to style one of the grouped elements differently by creating a new class or ID.

HTML Structure

Here’s the HTML structure for this lesson. Don’t forget to link the CSS file!

<!DOCTYPE html>
<html>
<head>
  <title>Grouping in CSS</title>
  <link rel="stylesheet" href="styles.css"> <!-- Link to your CSS file -->
</head>
<body>
  <h1>Heading 1</h1>
  <h2>Heading 2</h2>
  <p class="text">This is a paragraph.</p>
  <p id="special-text">This is a special paragraph.</p>
</body>
</html>

Grouping Selectors

You can group selectors by separating them with commas. For example, in your styles.css file:

h1, h2, .text {
  color: blue;
  font-size: 18px;
}

This applies the same styles to <h1>, <h2>, and elements with the class .text.

Styling One Element Differently

To style the #special-text paragraph differently, create a new rule in your CSS file:

#special-text {
  color: red;
  font-weight: bold;
}

Now, the special paragraph stands out while the rest share the grouped styles.

Final Output

Here’s how your styles.css file should look:

h1, h2, .text {
  color: blue;
  font-size: 18px;
}

#special-text {
  color: red;
  font-weight: bold;
}

Grouping selectors saves time and makes your CSS more efficient. Try it out in your next project!

socket_003:Sending and Receiving Video over Sockets

codeaddict — Thu, 30 Jan 2025 21:22:01 +0900

In this tutorial, we will explore how to send and receive video frames over a network using Python sockets. We will break down both the server and client code to understand how video data is transmitted and displayed in real-time.

Overview

Server Code: The server listens for incoming connections, receives video frames from the client, and displays them.
Client Code: The client reads video frames from a video file, sends them to the server, and displays them locally.

Server Code Breakdown

import socket
import cv2
import pickle
import struct

def recv_exact(sock, size):
    """Receive exactly `size` bytes from the socket."""
    data = b""
    while len(data) < size:
        packet = sock.recv(size - len(data))
        if not packet:
            return None
        data += packet
    return data

# Create a TCP socket
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(('localhost', 12345))
server_socket.listen(1)
print("Waiting for client connection...")

client_socket, addr = server_socket.accept()
print("Connected to:", addr)

try:
    while True:
        # Receive the frame size (4 bytes)
        packed_size = client_socket.recv(4)
        if not packed_size:
            break
        frame_size = struct.unpack("I", packed_size)[0]

        # Receive the complete frame data
        frame_data = recv_exact(client_socket, frame_size)
        if frame_data is None:
            break

        # Deserialize and decode the frame
        frame = cv2.imdecode(pickle.loads(frame_data), cv2.IMREAD_COLOR)

        # Display the frame
        cv2.imshow("Server Camera", frame)

        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

except Exception as e:
    print("Error:", e)

finally:
    cv2.destroyAllWindows()
    client_socket.close()
    server_socket.close()
    print("Connection closed.")

Key Functions and Concepts in Server Code

recv_exact(sock, size):

This function ensures that exactly size bytes are received from the socket. It is necessary because recv() may not always return the exact number of bytes requested.

Parameters:

sock: The socket object.
size: The number of bytes to receive.

2. socket.socket(socket.AF_INET, socket.SOCK_STREAM):

Creates a TCP socket.
AF_INET specifies the address family (IPv4).
SOCK_STREAM specifies the socket type (TCP).

3. server_socket.bind(('localhost', 12345)):

Binds the socket to the localhost on port 12345.

4. server_socket.listen(1):

Listens for incoming connections. The argument 1 specifies the maximum number of pending connections.

5. client_socket, addr = server_socket.accept():

Accepts a connection from a client. Returns a new socket object (client_socket) and the address of the client (addr).

6. struct.unpack("I", packed_size)[0]:

Unpacks the frame size from the received 4-byte data. "I" specifies an unsigned integer.

7. cv2.imdecode(pickle.loads(frame_data), cv2.IMREAD_COLOR):

Deserializes the frame data using pickle.loads() and decodes it into an image using cv2.imdecode().

8. cv2.imshow("Server Camera", frame):

Displays the received frame in a window titled “Server Camera”.

9. cv2.waitKey(1):

Waits for 1 millisecond for a key event. If the ‘q’ key is pressed, the loop breaks.

Client Code Breakdown

import socket
import cv2
import pickle
import struct
import time

client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect(('localhost', 12345))

video_path = 'mix.mp4'  # Replace with your video file path
cap = cv2.VideoCapture(video_path)

fps = cap.get(cv2.CAP_PROP_FPS)
print(f"Video FPS: {fps}")

try:
    while True:
        start_time = time.time()
        ret, frame = cap.read()
        if not ret:
            break

        # Resize and compress the frame
        frame = cv2.resize(frame, (640, 480))
        ret, buffer = cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, 80])
        data = pickle.dumps(buffer)
        message_size = struct.pack("I", len(data))
        client_socket.sendall(message_size + data)

        cv2.imshow("Client Camera", frame)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

        time_to_sleep = max(0, (1 / fps) - (time.time() - start_time))
        time.sleep(time_to_sleep)

except KeyboardInterrupt:
    print("Client stopped.")

finally:
    cap.release()
    client_socket.close()
    cv2.destroyAllWindows()

Key Functions and Concepts in Client Code

client_socket.connect(('localhost', 12345)):

Connects the client socket to the server at localhost on port 12345.

2. cv2.VideoCapture(video_path):

Opens the video file specified by video_path.

3. cap.get(cv2.CAP_PROP_FPS):

Retrieves the frames per second (FPS) of the video.

4. cap.read():

Reads the next frame from the video. Returns ret (a boolean indicating success) and frame (the actual frame).

5. cv2.resize(frame, (640, 480)):

Resizes the frame to 640x480 pixels.

6. cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, 80]):

Encodes the frame as a JPEG image with 80% quality.

7. pickle.dumps(buffer):

Serializes the encoded frame data into a byte stream.

8. struct.pack("I", len(data)):

Packs the length of the serialized frame data into a 4-byte unsigned integer.

9. client_socket.sendall(message_size + data):

Sends the frame size followed by the frame data to the server.

Conclusion

This tutorial demonstrated how to send and receive video frames over a network using Python sockets. The server receives and displays the frames, while the client reads frames from a video file, sends them to the server, and displays them locally. By understanding the key functions and concepts, you can build more complex video streaming applications.

socket_002: Real-Time Camera Streaming with Sockets

codeaddict — Thu, 30 Jan 2025 12:23:42 +0900

In this tutorial, we’ll create a server that captures video from a webcam and streams it to a client over a network. The client will receive the video frames and display them in real-time.

Prerequisites

Install the required libraries:

pip install opencv-python

2. Ensure you have a webcam connected to your machine.

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

How It Works

Server Side:

Capture video frames from the webcam using OpenCV.
Encode the frames into a byte stream.
Send the encoded frames to the client over a socket.

2. Client Side:

Receive the encoded frames from the server.
Decode the frames and display them using OpenCV.

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

Step 1: Create the Camera Streaming Server

Save the following code in a file named camera_server.py:

import socket
import cv2
import pickle
import struct

# Create a TCP socket
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Bind the socket to an IP address and port
server_address = ('localhost', 12345)
server_socket.bind(server_address)

# Listen for incoming connections
server_socket.listen(1)
print("Camera server is listening on port 12345...")

# Accept a connection from a client
client_socket, client_address = server_socket.accept()
print(f"Connection established with {client_address}")

# Set a timeout for the client socket (e.g., 5 seconds)
client_socket.settimeout(5.0)

# Initialize a buffer to store the incoming data
data_buffer = b""
# Size of the payload (4 bytes for the length of the frame)
payload_size = struct.calcsize("L")

try:
    while True:
        try:
            # Receive the frame size from the client
            while len(data_buffer) < payload_size:
                packet = client_socket.recv(4096)
                if not packet:  # Client disconnected
                    print("Client disconnected.")
                    break
                data_buffer += packet

            if not data_buffer:
                break  # Exit if client disconnected

            # Extract the frame size from the buffer
            packed_msg_size = data_buffer[:payload_size]
            data_buffer = data_buffer[payload_size:]
            msg_size = struct.unpack("L", packed_msg_size)[0]

            # Receive the frame data from the client
            while len(data_buffer) < msg_size:
                packet = client_socket.recv(4096)
                if not packet:  # Client disconnected
                    print("Client disconnected.")
                    break
                data_buffer += packet

            if not data_buffer:
                break  # Exit if client disconnected

            # Extract the frame from the buffer
            frame_data = data_buffer[:msg_size]
            data_buffer = data_buffer[msg_size:]

            # Deserialize the frame
            frame = pickle.loads(frame_data)

            # Overlay text on the frame to indicate it's from the server
            cv2.putText(frame, "From Server", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

            # Display the frame in a window
            cv2.imshow("Server Camera", frame)
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break

        except socket.timeout:
            print("No data received from client. Closing connection.")
            break

except KeyboardInterrupt:
    print("Server stopped.")

finally:
    # Release resources
    cv2.destroyAllWindows()
    client_socket.close()
    server_socket.close()

Step 2: Create the Camera Streaming Client

Save the following code in a file named camera_client.py:

import socket
import cv2
import pickle
import struct

# Create a TCP socket
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Connect to the server
server_address = ('localhost', 12345)
client_socket.connect(server_address)

# Open the webcam
cap = cv2.VideoCapture(0)

try:
    while True:
        # Capture a frame from the webcam
        ret, frame = cap.read()
        if not ret:
            break

        # Serialize the frame into a byte stream
        data = pickle.dumps(frame)
        # Pack the length of the data into a 4-byte header
        message_size = struct.pack("L", len(data))

        # Send the frame to the server
        client_socket.sendall(message_size + data)

        # Display the original frame in a window (optional)
        cv2.imshow("Client Camera", frame)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

except KeyboardInterrupt:
    print("Client stopped.")

finally:
    # Release resources
    cap.release()
    client_socket.close()
    cv2.destroyAllWindows()

Step 3: Run the Code

Open two terminal windows:

One for the server.
One for the client.

2. Run the server:

In the first terminal, navigate to the directory where camera_server.py is saved.
Run the server using the following command:

python camera_server.py

The server will start and display:

Camera server is listening on port 12345…

3. Run the client:

In the second terminal, navigate to the directory where camera_client.py is saved.
Run the client using the following command:
python camera_client.py

python camera_client.py

A window will open displaying the live camera stream from the server.

4. Stop the streaming:

Press q in the client window to stop the stream and close the window.

How It Works

The server captures video frames from the webcam using OpenCV.
Each frame is serialized into a byte stream using pickle.
The server sends the frame size (as a 4-byte header) followed by the frame data to the client.
The client receives the frame size and data, deserializes the frame, and displays it using OpenCV.

Key Takeaways

Sockets can be used to stream real-time data, such as video, between a server and a client.
OpenCV is a powerful library for capturing and processing video frames.
Serialization (using pickle) is necessary to send complex data (like images) over sockets.

socket_001: Introduction to Sockets in Python

codeaddict — Thu, 30 Jan 2025 12:13:45 +0900

Sockets are the backbone of network communication. They allow programs to send and receive data over a network, enabling applications to communicate with each other. Whether you’re building a chat application, a file transfer system, or a web server, understanding sockets is essential.

In this tutorial, we’ll cover the basics of sockets, including what they are, how they work, and how to create a simple client-server communication using Python.

What is a Socket?

A socket is an endpoint for communication between two machines. It combines an IP address and a port number to uniquely identify a connection. Sockets can be used for various types of communication, such as TCP (Transmission Control Protocol) and UDP (User Datagram Protocol).

TCP: Reliable, connection-oriented communication. Data is delivered in order and without errors.
UDP: Unreliable, connectionless communication. Data is sent without guaranteeing delivery or order.

In this tutorial, we’ll focus on TCP sockets, as they are the most commonly used.

Basic Socket Workflow

Server Side:

Create a socket.
Bind the socket to an IP address and port.
Listen for incoming connections.
Accept a connection from a client.
Send and receive data.

Client Side:

Create a socket.
Connect to the server’s IP address and port.
Send and receive data.

Basic Socket Commands and Syntax

Here are the fundamental socket commands in Python:

| Command/Syntax                | Description                                                                 |
|-------------------------------|-----------------------------------------------------------------------------|
| `socket.socket()`             | Creates a new socket.                                                       |
| `socket.bind((host, port))`   | Binds the socket to a specific IP address and port.                         |
| `socket.listen()`             | Puts the socket in listening mode (for servers).                            |
| `socket.accept()`             | Accepts an incoming connection (returns a new socket and client address).   |
| `socket.connect((host, port))`| Connects to a remote socket (for clients).                              |
| `socket.send(data)`           | Sends data to the connected socket.                                         |
| `socket.recv(buffer_size)`    | Receives data from the socket (up to `buffer_size` bytes).                  |
| `socket.close()`              | Closes the socket.                                                          |

Creating a Simple TCP Server and Client

Let’s create a basic TCP server and client to demonstrate how sockets work. — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

Step 1: Create the TCP Server

The server will listen for incoming connections and respond to messages from the client.

Save the following code in a file named server.py:

import socket

# Create a TCP socket
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Bind the socket to an IP address and port
server_address = ('localhost', 12345)
server_socket.bind(server_address)

# Listen for incoming connections
server_socket.listen(1)
print("Server is listening on port 12345...")

# Accept a connection
client_socket, client_address = server_socket.accept()
print(f"Connection established with {client_address}")

# Receive data from the client
data = client_socket.recv(1024).decode()
print(f"Received: {data}")

# Send a response to the client
response = "Hello from the server!"
client_socket.send(response.encode())

# Close the sockets
client_socket.close()
server_socket.close()

Step 2: Create the TCP Client

The client will connect to the server, send a message, and receive a response.

Save the following code in a file named client.py:

import socket

# Create a TCP socket
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Connect to the server
server_address = ('localhost', 12345)
client_socket.connect(server_address)

# Send data to the server
message = "Hello from the client!"
client_socket.send(message.encode())

# Receive a response from the server
data = client_socket.recv(1024).decode()
print(f"Received: {data}")

# Close the socket
client_socket.close()

Step 3: Run the Code

Follow these steps to run the server and client:

Open two terminal windows:

One for the server.
One for the client.

2. Run the server:

In the first terminal, navigate to the directory where server.py is saved.
Run the server using the following command:
python server.py

python server.py

The server will start and display:

Server is listening on port 12345…

3. Run the client:

In the second terminal, navigate to the directory where client.py is saved.
Run the client using the following command

python client.py

The client will send a message to the server and display the server’s response:

Received: Hello from the server

4. Observe the server output:

After the client runs, the server terminal will display:

Connection established with ('127.0.0.1', <client_port>) Received: Hello from the client!

How It Works

The server creates a socket, binds it to localhost:12345, and starts listening for connections.
The client creates a socket and connects to the server at localhost:12345.
The client sends a message ("Hello from the client!") to the server.
The server receives the message, prints it, and sends a response ("Hello from the server!") back to the client.
The client receives the response and prints it.
Both the client and server close their sockets.

Output

Server Output:

Server is listening on port 12345...
Connection established with ('127.0.0.1', <client_port>)
Received: Hello from the client!

Client Output:

Received: Hello from the server!

Key Takeaways

Sockets are the foundation of network communication.
A server listens for incoming connections, while a client initiates the connection.
The socket module in Python provides all the tools you need to create and manage sockets.
Always close sockets after use to free up resources.

Django REST Framework_001: Using a Custom User Model

codeaddict — Mon, 27 Jan 2025 10:48:18 +0900

In Django projects, working with users is a fundamental part of many applications. By default, Django provides the auth.User model, which includes basic user fields like username, email, password, etc. While sufficient for many scenarios, this default model may not always fit your application’s needs. To address this, Django allows you to define your own custom user model.

In this lesson, we will:

Learn how to define a custom user model.
Understand what the AUTH_USER_MODEL setting does and why it’s essential.
Discuss common issues when AUTH_USER_MODEL is not properly configured and how to resolve them.

Why Use a Custom User Model?

Sometimes, the default auth.User model may not meet the requirements of your application. For example, you might want to:

Add fields like phone_number, profile_picture, or date_of_birth.
Remove unnecessary fields that your application does not use.
Extend the default user authentication functionality.

Using a custom user model allows for these customizations while maintaining compatibility with Django’s built-in authentication system.

Steps to Create and Use a Custom User Model

Step 1: Create a New Django Project

Run the following commands to set up a Django project and app:

django-admin startproject custom_user_project
cd custom_user_project
django-admin startapp api

This creates the project custom_user_project and the app api.

Step 2: Define the Custom User Model

In the api app, define a custom user model in models.py. To create a custom user model, Django provides the AbstractUser class, which already includes the basic fields and methods of a user.

Here is an example:

from django.contrib.auth.models import AbstractUser
from django.db import models

class User(AbstractUser):
    # Add custom fields if needed
    phone_number = models.CharField(max_length=15, blank=True, null=True)

    def __str__(self):
        return self.username

This class:

Inherits from AbstractUser, which includes fields like username, email, password, etc.
Adds an optional phone_number field for additional functionality.

You can now use this User model as the user model for your project.

Step 3: Set AUTH_USER_MODEL

In the settings.py file, add the following:

AUTH_USER_MODEL = "api.User"

The AUTH_USER_MODEL setting tells Django to use your custom user model (api.User) instead of the default auth.User model.

Is AUTH_USER_MODEL a Predefined Keyword in Django? Yes, AUTH_USER_MODEL is a predefined setting in Django. By default, it is set to 'auth.User', which refers to Django’s built-in user model. When you create a custom user model, this setting must explicitly point to your model in the format '<app_name>.<model_name>'.

Why Do We Need AUTH_USER_MODEL?

If you don’t set AUTH_USER_MODEL and try to use a custom user model, Django will still reference the default auth.User. This creates conflicts, especially when you have relationships like groups or permissions in your custom user model.

For example, without AUTH_USER_MODEL, you may encounter the following error:

django.core.management.base.SystemCheckError: SystemCheckError: System check identified some issues:

ERRORS:
api.User.groups: (fields.E304) Reverse accessor 'Group.user_set' for 'api.User.groups' clashes with reverse accessor for 'auth.User.groups'.
        HINT: Add or change a related_name argument to the definition for 'api.User.groups' or 'auth.User.groups'.

This happens because Django tries to create reverse relationships for both auth.User and your custom user model. By setting AUTH_USER_MODEL, you prevent Django from referencing auth.User, resolving such conflicts.

Step 4: Apply Migrations

After defining your custom user model and setting AUTH_USER_MODEL, apply the migrations:

python manage.py makemigrations
python manage.py migrate

Django will now create the database schema for your custom user model.

Common Issues and Fixes

Problem: SystemCheckError (Reverse Accessor Clash)

As mentioned earlier, this error occurs when Django tries to reference both the default auth.User and your custom user model. The conflict arises because both models attempt to define reverse relationships with groups and permissions.

Solution

The solution is to set AUTH_USER_MODEL to your custom user model in settings.py:

AUTH_USER_MODEL = "api.User"

This ensures that Django uses your custom user model exclusively.

cpp_010: Arrays in C++

codeaddict — Sun, 26 Jan 2025 19:09:23 +0900

Arrays are one of the most fundamental data structures in C++, allowing you to store multiple values of the same type in a single container. In this lesson, we’ll introduce arrays, explain their syntax, and provide two examples — one basic and one advanced — to showcase their usage.

1. What is an Array?

An array is a collection of elements stored in contiguous memory locations, all of which share the same data type. You can think of it as a list of values indexed starting from 0.

2. Declaring and Initializing an Array

To declare an array in C++, use the following syntax:

type arrayName[size];

type: The data type of the array elements (e.g., int, float, char).
arrayName: The name of the array.
size: The number of elements the array can hold.

You can initialize an array during declaration:

int numbers[5] = {10, 20, 30, 40, 50};

3. Example 1: Basic Array

Let’s create a program that prints all elements of an integer array.

#include <iostream>
using namespace std;

int main() {
    int numbers[5] = {10, 20, 30, 40, 50}; // Declaration and initialization

    cout << "Array Elements:" << endl;
    for (int i = 0; i < 5; i++) { // Loop through the array
        cout << "numbers[" << i << "] = " << numbers[i] << endl;
    }
    return 0;
}

Output:

Array Elements:  
numbers[0] = 10  
numbers[1] = 20  
numbers[2] = 30  
numbers[3] = 40  
numbers[4] = 50

Explanation:

The for loop iterates over the array indices from 0 to 4.
The array elements are accessed using numbers[i].

4. Example 2: Array with User Input

In this example, we’ll calculate the average of numbers entered by the user.

#include <iostream>
using namespace std;

int main() {
    const int SIZE = 5;
    float numbers[SIZE];
    float sum = 0.0;

    cout << "Enter " << SIZE << " numbers:" << endl;

    // Taking user input
    for (int i = 0; i < SIZE; i++) {
        cin >> numbers[i];
        sum += numbers[i]; // Accumulating the sum
    }

    // Calculating the average
    float average = sum / SIZE;

    // Displaying the array and average
    cout << "Array Elements:" << endl;
    for (int i = 0; i < SIZE; i++) {
        cout << "numbers[" << i << "] = " << numbers[i] << endl;
    }
    cout << "Average: " << average << endl;

    return 0;
}

Output (Example):

Enter 5 numbers:  
10  
20  
30  
40  
50  
Array Elements:  
numbers[0] = 10  
numbers[1] = 20  
numbers[2] = 30  
numbers[3] = 40  
numbers[4] = 50  
Average: 30

Explanation:

The program prompts the user to input 5 numbers.
The for loop calculates the sum while storing the numbers in the array.
The average is computed and displayed along with the array elements.

CSS_003_Understanding Descendant and Child Selectors in C

codeaddict — Sun, 26 Jan 2025 17:15:41 +0900

In this blog post, we’ll dive into two important CSS selectors: descendant and child selectors. Understanding these will help you write precise and efficient styles for your HTML elements. Let’s explore these concepts with examples and practical code snippets.

HTML Structure

Here’s the HTML structure for this lesson:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>CSS Selectors</title>
  <link rel="stylesheet" href="main.css">
</head>
<body>
  <ul>
    <li>Direct Child 1</li>    
    <ol>
      <li>Nested Child 1</li>
      <li>Nested Child 2</li>
    </ol>
    <li>Direct Child 1</li>
  </ul>
</body>
</html>

CSS Styles

Here’s the CSS file (main.css) used to demonstrate descendant and child selectors:

/* Descendant Selector */
ul li {
  color: black;
  font-size: 20px; /* Applies to all <li> elements within a <ul>, at any level */
}

/* Child Selector */
ul > li {
  color: green; /* Applies only to direct <li> children of the <ul> */
}

Descendant Selector ( )

The descendant selector targets all nested elements of a specified parent, regardless of how deep they are in the hierarchy.
Example in Action:
For the HTML structure above, the CSS rule ul li will apply the styles to:

“Direct Child 1”
“Nested Child 1”
“Nested Child 2”
“Direct Child 2”

This makes descendant selectors useful when you want to style all child elements, no matter their nesting level.

Child Selector (>)

The child selector, on the other hand, targets only the direct children of a parent element.
Example in Action:
For the CSS rule ul > li, only "Direct Child 1" and "Direct Child 2" will be styled, leaving "Nested Child 1" and "Nested Child 2" unaffected.

This selector is perfect when you want to limit your styles to elements that are directly inside a parent.

Visualizing the Difference

Here’s a quick summary to help differentiate:

ul li → Styles all <li> elements nested inside a <ul>.
ul > li → Styles only the immediate <li> children of a <ul>.

Understanding how to use descendant and child selectors effectively allows you to manage complex layouts with greater control. In the next post, we’ll explore advanced CSS combinators for even more powerful styling.

cpp_009: While Loops and Break Statement in C++

codeaddict — Wed, 15 Jan 2025 22:41:29 +0900

Loops allow for repeated execution of code blocks, and the while loop is a foundational construct in C++ for controlling repetition based on a condition. In this lesson, we’ll cover the syntax of the while loop, demonstrate a basic example, and introduce the break statement for enhanced control flow.

1. While Loop Syntax

A while loop in C++ repeatedly executes a block of code as long as its condition evaluates to true.

while (condition) {
    // Code block to execute
}

Condition: The loop continues to run as long as this evaluates to true.
The loop terminates when the condition becomes false.

2. Example 1: Basic While Loop

This example prints numbers from 1 to 5 using a while loop.

#include <iostream>
using namespace std;

int main() {
    int i = 1;  // Initialization
    while (i <= 5) {  // Condition
        cout << "Number: " << i << endl;
        i++;  // Increment
    }
    return 0;
}

Output:

Number: 1  
Number: 2  
Number: 3  
Number: 4  
Number: 5

Explanation:

The loop starts with i = 1.
The condition i <= 5 ensures the loop runs five times.
The i++ increments the variable i with each iteration, moving toward the loop's termination.

3. Example 2: Using break in a While Loop

The break statement is used to exit a loop prematurely, regardless of the condition. Here’s an example that demonstrates how to use it effectively.

#include <iostream>
using namespace std;

int main() {
    int i = 1;  // Initialization
    while (true) {  // Infinite loop
        if (i > 5) {  // Break condition
            break;
        }
        cout << "Number: " << i << endl;
        i++;
    }
    return 0;
}

Output:

Number: 1  
Number: 2  
Number: 3  
Number: 4  
Number: 5

Explanation:

The while (true) creates an infinite loop.
The if (i > 5) checks whether i exceeds 5.
When i > 5, the break statement terminates the loop, skipping the remaining iterations.

Summary

The while loop is a versatile tool for repeating tasks, especially when the number of iterations is not predetermined. The break statement enhances its flexibility, allowing you to exit the loop under specific conditions.

Python Intermediate_004_ Nested Classes

codeaddict — Sun, 12 Jan 2025 22:29:57 +0900

When working on Python projects, you might encounter situations where a class needs to contain another class. This is where nested classes can be helpful. In this post, we will understand what nested classes are, when to use them, and how they compare to using two separate classes. Let’s begin with a simple example using two separate classes and then explore how the same functionality can be achieved with nested classes.

Two Separate Classes Example

Let’s take a real-world example of a School and its Students:

# Two separate classes
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        return f"My name is {self.name}, and I am {self.age} years old."

class School:
    def __init__(self, name):
        self.name = name
        self.students = []

    def add_student(self, student):
        self.students.append(student)

    def display_students(self):
        print(f"Students in {self.name}:")
        for student in self.students:
            print(student.introduce())

# Usage
school = School("Greenwood High")
student1 = Student("Alice", 15)
student2 = Student("Bob", 16)

school.add_student(student1)
school.add_student(student2)
school.display_students()

Output:

Students in Greenwood High:
My name is Alice, and I am 15 years old.
My name is Bob, and I am 16 years old.

How It Works:

We have two separate classes: Student and School.
The School class uses Student objects to store information about its students.
While this approach works well, it creates two separate classes that exist independently in the global namespace.

Nested Classes Example

Now let’s refactor the above example to use a nested class. Here, we’ll define the Student class inside the School class:

# Nested class example
class School:
    def __init__(self, name):
        self.name = name
        self.students = []

    # Define the Student class inside School
    class Student:
        def __init__(self, name, age):
            self.name = name
            self.age = age

        def introduce(self):
            return f"My name is {self.name}, and I am {self.age} years old."

    def add_student(self, name, age):
        # Create a Student object using the nested class
        student = self.Student(name, age)
        self.students.append(student)

    def display_students(self):
        print(f"Students in {self.name}:")
        for student in self.students:
            print(student.introduce())

# Usage
school = School("Greenwood High")
school.add_student("Alice", 15)
school.add_student("Bob", 16)
school.display_students()

Output:

Students in Greenwood High:
My name is Alice, and I am 15 years old.
My name is Bob, and I am 16 years old.

Key Differences Between the Two Approaches

When to Use Nested Classes

Use nested classes when:

Tight Coupling: The inner class (e.g., Student) is only relevant to the outer class (e.g., School).
Encapsulation: You want to hide the inner class from external use to reduce clutter in the global namespace.
Logical Grouping: Grouping related logic together makes your code easier to read and maintain.

cpp_008: for Loops in C++

codeaddict — Sun, 12 Jan 2025 09:09:36 +0900

Loops are essential in programming, and the for loop in C++ is one of the most versatile tools for iterating over sequences or performing repetitive tasks. In this tutorial, we’ll start with the syntax of the for loop and explore three examples, progressing from basic to more advanced scenarios.

1. For Loop Syntax

A for loop in C++ consists of three components:

for (initialization; condition; increment/decrement) {
    // Code block to execute
}

Initialization: Sets the starting point for the loop (e.g., int i = 0).
Condition: The loop continues as long as this evaluates to true.
Increment/Decrement: Updates the loop variable at each iteration.

2. Example 1: Basic Loop

This example demonstrates a simple loop that prints numbers from 1 to 5.

#include <iostream>
using namespace std;

int main() {
    for (int i = 1; i <= 5; i++) {
        cout << "Number: " << i << endl;
    }
    return 0;
}

Output:

Number: 1  
Number: 2  
Number: 3  
Number: 4  
Number: 5

Explanation:

int i = 1: Start from 1.
i <= 5: Continue as long as i is less than or equal to 5.
i++: Increment i by 1 at each iteration.

3. Example 2: Loop with Conditionals

This example adds a conditional statement inside the loop to print even numbers between 1 and 10.

#include <iostream>
using namespace std;
int main() {
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            cout << "Even Number: " << i << endl;
        }
    }
    return 0;
}

Output:

Even Number: 2  
Even Number: 4  
Even Number: 6  
Even Number: 8  
Even Number: 10

Explanation:

The if (i % 2 == 0) condition checks if i is divisible by 2.
Only even numbers are printed.

4. Example 3: Nested For Loops

In this example, we use nested loops to display a multiplication table from 1 to 5.

#include <iostream>
using namespace std;
int main() {
    for (int i = 1; i <= 5; i++) {
        for (int j = 1; j <= 5; j++) {
            cout << i << " x " << j << " = " << i * j << "\t";
        }
        cout << endl; // New line after each row
    }
    return 0;
}

Output:

1 x 1 = 1   1 x 2 = 2   1 x 3 = 3   1 x 4 = 4   1 x 5 = 5  
2 x 1 = 2   2 x 2 = 4   2 x 3 = 6   2 x 4 = 8   2 x 5 = 10  
3 x 1 = 3   3 x 2 = 6   3 x 3 = 9   3 x 4 = 12  3 x 5 = 15  
4 x 1 = 4   4 x 2 = 8   4 x 3 = 12  4 x 4 = 16  4 x 5 = 20  
5 x 1 = 5   5 x 2 = 10  5 x 3 = 15  5 x 4 = 20  5 x 5 = 25

Explanation:

The outer loop (for i) iterates through rows.
The inner loop (for j) handles each column in the row.
i * j computes the product for the multiplication table.

CSS_002_Styling Borders and Backgrounds with HTML and CSS

codeaddict — Sun, 12 Jan 2025 08:39:45 +0900

In this blog post, we’ll explore two powerful CSS properties: borders and backgrounds. These properties can help add definition and visual appeal to your HTML elements. Let’s dive in with practical examples and explanations.

HTML Structure

Here’s the updated HTML structure for this lesson:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>CSS Styling</title>
  <link rel="stylesheet" href="main.css">
</head>
<body>
  <div class="container">
    <h1>This is my first CSS practice</h1>
    <h2>CSS is fun</h2>
  </div>

  <div>
    <img src="sun.jpeg" class="borderImg">
  </div>
</body>
</html>

CSS Styles

Here’s the CSS file (main.css) used to style the borders and backgrounds:

/* Border Styling */
.borderImg {
  border: 5px solid red; /* Creates a solid red border around the element */
}

Border Property

The border property in CSS allows you to create borders around elements. It consists of three parts:

Width: Thickness of the border (e.g., 2px, 5px).
Style: Type of the border (e.g., solid, dashed, dotted, double, etc.).
Color: The color of the border (e.g., red, blue, or hex codes like #ff0000).

Example of Different Border Styles:

/* Solid Border */
.solidBorder {
  border: 3px solid blue;
}

You can mix and match these properties to customize your borders.

Background Properties

The background property in CSS allows you to customize the look and feel of your webpage. You can:

Use images (background-image).
Control how images repeat (background-repeat).
Set the image size (background-size).

Example of Background Styling:

body {
  background-image: url(nature.jpeg);
  background-repeat: no-repeat;
  background-size: cover;

}

Let’s break down each property used in the code:

1. background-image

This property is used to set an image as the background of an element.
Syntax:

background-image: url('image-file-path');

url('nature.jpeg'): Specifies the path to the image you want to use. In this case, the file nature.jpeg is located in the same directory as the HTML file.

2. background-repeat

This property controls whether the background image is repeated.
Syntax:

background-repeat: value;

Values:

repeat: Default value. The image is repeated both horizontally and vertically.
repeat-x: The image is repeated horizontally only.
repeat-y: The image is repeated vertically only.
no-repeat: The image is not repeated.

In our example, background-repeat: no-repeat; ensures that the image appears only once on the page.

3. background-size

This property specifies the size of the background image.
Syntax:

background-size: value;

Values:

auto: Default value. The image is displayed at its original size.
cover: Scales the image to completely cover the element's area while maintaining its aspect ratio.
contain: Scales the image to fit within the element's area while maintaining its aspect ratio.

In our example, background-size: cover; makes the image cover the entire viewport. Even if the viewport size changes (e.g., resizing the browser window), the image will adjust accordingly to cover the full area without distortion.

Final Output

CSS_001_Styling Basics with HTML and CSS

codeaddict — Wed, 8 Jan 2025 21:57:28 +0900

CSS is a powerful tool that allows you to bring life and style to your HTML elements. In this blog post, we’ll look at a simple example of how CSS can transform your webpage with gradients, shadows, and color effects. We’ll explain the code step by step to understand how each line contributes to the final result.

HTML Structure

Here’s the simple HTML structure we are working with:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>CSS Styling</title>
  <link rel="stylesheet" href="main.css">
</head>
<body>
  <div class ="container">
  <h1>This is my first CSS practice </h1>
  <h2>CSS is fun</h2>
</div>
</body>
</html>

Explanation:

<!DOCTYPE html>: Declares the document type as HTML5.
<html lang="en">: Specifies that the language of the document is English.
<head>: Contains metadata and links to external resources.

<meta charset="UTF-8">: Sets the character encoding to UTF-8, allowing a wide range of characters.
<meta name="viewport" content="width=device-width, initial-scale=1.0">: Makes the page responsive by setting the viewport width to the device’s screen width.
<title>My CSS</title>: Sets the title of the webpage (visible on the browser tab).
<link rel="stylesheet" href="main.css">: Links an external CSS file (main.css) to style the HTML elements.

<body>: Contains the main content of the webpage.

<div class="container">: Creates a container div to group and style the content.
<h1></h1>: Defines a level-one heading with the text "You are the CSS."
<h2></h2>: Defines a level-two heading with the text "Anyone escaped there."

CSS Styles

Here’s the CSS used to style the HTML elements:

.container {
 
  background: linear-gradient(to left, #9d0dbd, #df9fed);
  box-shadow: 3px 5px 3px blue;
}

h1 {
  color: black;
  text-shadow: 5px 5px 5px rgb(116, 113, 113);

}

h2 {

  color: rgb(5, 116, 22);
  text-shadow: 5px 5px 5px rgb(116, 113, 113);
}

Explanation of Each CSS Rule

1. .container

The container class applies styles to the <div> element and everything inside it.

background: linear-gradient(to left, #9d0dbd, #df9fed);

This creates a gradient background that transitions from purple (#9d0dbd) to light pink (#df9fed), moving from right to left.

color: blue;

Sets the default text color inside the container to blue.

box-shadow: 3px 5px 3px blue;

Adds a shadow around the container. The parameters are:
3px: Horizontal shadow.
5px: Vertical shadow.
3px: Blur radius.
blue: Color of the shadow.

2. h1

The h1 tag defines the first header.

color: black;

Sets the text color to black.

text-shadow: 10px, 100px;

This line is invalid because text-shadow requires four values (x-offset, y-offset, blur-radius, and color). It won’t work and should be removed.

text-shadow: 30px 10px 10px gray;

Correctly applies a shadow to the text. The parameters are:
30px: Horizontal offset (moves shadow to the right).
10px: Vertical offset (moves shadow down).
10px: Blur radius (softens the shadow edges).
gray: Shadow color.

3. h2

The h2 tag defines the second header.

color: rgb(0, 204, 255);

Sets the text color to a bright cyan using RGB values:
0: Red intensity.
204: Green intensity.
255: Blue intensity.

Final Result

When the above code is executed, here’s what you will see:

A container with a gradient background (purple to pink) and a blue shadow.
A level-one heading (h1) with black text and a gray shadow that appears offset and slightly blurred.
A level-two heading (h2) with bright cyan text.

cpp_007:Introduction to String Modifiers in C++ , Mastering String Manipulation

codeaddict — Mon, 6 Jan 2025 23:00:43 +0900

In C++, the std::string class provides a variety of functions to modify and manipulate strings efficiently. This tutorial is perfect for beginners looking to master string operations such as appending, erasing, inserting, finding, replacing, and more. Let’s dive into these powerful tools with examples and outputs.

1. Appending to a String

The append() function and the + operator allow you to concatenate strings.

Syntax:

string.append(str) - Appends the string str to the end of the string.
string + str - Concatenates str to the string.

Example 1: Appending Strings

#include <iostream>
using namespace std;

int main() {
    string greeting = "Hello";
    string name = "World";

    // Using append()
    greeting.append(", ").append(name);
    cout << "Greeting with append: " << greeting << endl;

    // Using + operator
    string fullGreeting = greeting + "!";
    cout << "Final Greeting: " << fullGreeting << endl;

    return 0;
}

Output:

Greeting with append: Hello, World
Final Greeting: Hello, World!

2. Erasing Characters or Substrings

The erase() function removes characters from a string.

Syntax:

string.erase(index, length) - Removes length characters starting from index.

Example 2: Erasing a Substring

#include <iostream>
using namespace std;

int main() {
    string sentence = "The quick brown fox jumps over the lazy dog.";

    // Removing a substring
    sentence.erase(4, 6);  // Remove "quick " (starting at index 4, length 6)
    cout << "After erase: " << sentence << endl;

    return 0;
}

Output:

After erase: The brown fox jumps over the lazy dog.

3. Inserting into a String

The insert() function adds characters or substrings at a specific index.

Syntax:

string.insert(index, str) - Inserts the string str at the specified index.

Example 3: Inserting a Substring

#include <iostream>
using namespace std;

int main() {
    string sentence = "Hello World!";

    // Insert a substring
    sentence.insert(6, "Beautiful ");
    cout << "After insert: " << sentence << endl;

    return 0;
}

Output:

After insert: Hello Beautiful World!

4. Finding and Replacing Substrings

The find() function locates the first occurrence of a substring, while replace() replaces a portion of the string.

Syntax:

string.find(str) - Returns the index of the first occurrence of str or string::npos if not found.
string.replace(index, length, str) - Replaces length characters starting at index with str.

Example 4: Find and Replace

#include <iostream>
using namespace std;

int main() {
    string sentence = "I love apples.";

    // Finding a substring
    size_t pos = sentence.find("apples");
    if (pos != string::npos) {
        // Replacing the substring
        sentence.replace(pos, 6, "oranges");
    }
    cout << "After replace: " << sentence << endl;

    return 0;
}

Output:

After replace: I love oranges.

5. Extracting Substrings

The substr() function retrieves a portion of the string.

Syntax:

string.substr(index, length) - Returns a substring starting at index with length characters.

Example 5: Substring Extraction

#include <iostream>
using namespace std;

int main() {
    string sentence = "The quick brown fox";

    // Extracting a substring
    string word = sentence.substr(10, 5);  // Starting at index 10, length 5
    cout << "Extracted word: " << word << endl;

    return 0;
}

Output:

Extracted word: brown

6. Comparing Strings

The compare() function compares two strings lexicographically.

Syntax:

string.compare(str) - Returns:
A negative value if the string is less than str.
Zero if the string is equal to str.
A positive value if the string is greater than str.

Example 6: Comparing Strings

#include <iostream>
using namespace std;

int main() {
    string str1 = "apple";
    string str2 = "banana";

    int result = str1.compare(str2);
    if (result < 0) {
        cout << str1 << " comes before " << str2 << " in lexicographical order." << endl;
    } else if (result > 0) {
        cout << str1 << " comes after " << str2 << " in lexicographical order." << endl;
    } else {
        cout << str1 << " is equal to " << str2 << "." << endl;
    }

    return 0;
}

Output:

apple comes before banana in lexicographical order.

7. Removing the Last Character

The pop_back() function removes the last character of the string.

Syntax:

string.pop_back() - Removes the last character of the string.

Example 7: Removing the Last Character

#include <iostream>
using namespace std;

int main() {
    string sentence = "Hello World!";

    // Removing the last character
    sentence.pop_back();
    cout << "After pop_back: " << sentence << endl;

    return 0;
}

Output:

After pop_back: Hello World

Conclusion

By mastering these string modifiers, you can handle any string manipulation task in C++ with confidence. Practice these examples and try combining multiple functions to solve more complex problems.

cpp_006_Introduction to getline and cin.getline in C++: Handling User Input with Spaces

codeaddict — Sun, 5 Jan 2025 23:12:33 +0900

In C++, reading strings can be tricky when the input contains spaces. For instance, the default cin input method stops reading input when it encounters a whitespace character. In this tutorial, we’ll explore how to handle input with spaces using getline() and cin.getline().

1. Problem with cin and Spaces

By default, when you use cin >> variable, it reads input until it encounters a whitespace (space, tab, or newline). This makes it difficult to read full sentences or strings with spaces.

Code Example:

Example 1: Input with Multiple Words

Let’s examine an example where multiple words are entered, and we see how cin >> processes them:

#include <iostream>
using namespace std;

int main() {
    string firstWord;
    string leftover1;
    string leftover2;
    string leftover3;
    string leftover4;

    // Using cin to read input (stops at space)
    cout << "Enter a greeting: ";
    cin >> firstWord;  // Reads the first word only
    cout << "You entered: " << firstWord << endl;

    // Reading leftover input after the first word
    cin >> leftover1;  // Reads the next word
    cout << "Leftover input: " << leftover1 << endl;

    cin >> leftover2;  // Reads the next word
    cout << "Leftover input: " << leftover2 << endl;

    cin >> leftover3;  // Reads the next word
    cout << "Leftover input: " << leftover3 << endl;

    cin >> leftover4;  // Reads the next word
    cout << "Leftover input: " << leftover4 << endl;

    return 0;
}

Example 1: Case 1 — Input: “fd dfd”

If you input fd dfd and press Enter:

The first cin >> firstWord; reads fd (only the first word before the space).
The following cin >> leftoverX; calls will read the next words from the leftover input.

Output:

Enter a greeting: hi there
You entered: hi
Leftover input: there

Explanation:

cin >> firstWord; captures hi (first word).
The space after hi is left in the input buffer.
cin >> leftover1; reads there, as it’s the next available word in the buffer.
Since there are no more words in the buffer after there, the remaining cin >> leftover2, cin >> leftover3, and cin >> leftover4 calls result in no input being captured.

Example 1: Case 2 — Input: “hello today is cold, what are you wearing”

Now, if you input a longer sentence like hello today is cold, what are you wearing:

cin >> firstWord; reads hello (the first word before the first space).
The following cin >> leftoverX; calls will read one word at a time from the remaining input.

Output:

Enter a greeting: hello today is cold, what are you wearing
You entered: hello
Leftover input: today
Leftover input: is
Leftover input: cold,
Leftover input: what

Explanation:

cin >> firstWord; captures hello.
The space after hello is left in the buffer, so the next cin >> leftover1; reads today.
After reading today, the space after it leaves the buffer, so cin >> leftover2; captures is.
This continues until all words are processed, one by one, in each call to cin >> leftoverX;.

This shows that cin >> captures one word at a time, and any remaining words are handled in subsequent calls to cin >>.

2. When to Use getline() to Capture Full Sentences

To handle input with spaces properly and capture full sentences or phrases, cin >> is not sufficient because it only reads one word at a time. Instead, we use getline() to read the entire line of input, including spaces.

Modified Code Using getline() to Capture Full Sentences:

#include <iostream>
using namespace std;

int main() {
    string fullInput;

    // Using getline() to read a full line of input, including spaces
    cout << "Enter a full sentence: ";
    getline(cin, fullInput);  // Reads the entire line
    cout << "You entered: " << fullInput << endl;

    return 0;
}

Output:

Enter a full sentence: hello today is cold, what are you wearing
You entered: hello today is cold, what are you wearing

Explanation:

getline(cin, fullInput); reads the entire line of input, including spaces between words.
It captures the full sentence hello today is cold, what are you wearing in the fullInput string.

3. Using cin.getline() for Fixed-Length Input

cin.getline() is another version of getline() but with an additional feature. It allows you to specify the maximum number of characters that can be read. If the input exceeds this limit, it will be truncated, and any excess characters will remain in the input buffer for future use.

Code Example:

#include <iostream>
using namespace std;

int main() {
    char greeting[50];  // Buffer size

    // Using cin.getline() to read up to 50 characters
    cout << "Enter a greeting: ";
    cin.getline(greeting, 50);
    cout << "You entered: " << greeting << endl;

    return 0;
}

Output:

Enter a greeting: Hello there, how are you doing?
You entered: Hello there, how are you doing?

4. Key Differences Between getline() and cin.getline()

getline(cin, string) works with std::string and automatically adjusts the string size.
cin.getline(char array[], size) works with character arrays and requires you to define a fixed size for the buffer.

Conclusion

Handling user input in C++ can be challenging when the input contains spaces. The default cin >> behavior stops at spaces, but by using getline() or cin.getline(), you can easily capture full sentences or control the size of the input buffer. Understanding these functions helps you better manage user input and avoid common pitfalls.

Python Intermediate_005: Working with the Requests Library

codeaddict — Sat, 4 Jan 2025 19:45:30 +0900

The requests library in Python is a powerful tool for making HTTP requests, allowing you to interact with APIs, fetch data from websites, and send data to servers. It's simple, user-friendly, and perfect for beginners.

Installation

Install the requests library using pip if you don’t have it installed:

pip install requests

Key Features and Examples

Let’s dive into the most useful and practical use cases for the requests library, with clear explanations and code examples.

1. Making a Simple GET Request

A GET request is used to fetch data from a server.

Code Example:

import requests

response = requests.get("https://api.github.com")
print("Status Code:", response.status_code)
print("Response Body:", response.text)

Explanation:

1. response.status_code:

Displays the HTTP status code (e.g., 200 for success, 404 for not found).

2. response.text:

Prints the response body (data returned by the server) as a string.

Output:

Status Code: 200
Response Body: {
  "current_user_url": "https://api.github.com/user",
  "current_user_authorizations_html_url": "https://github.com/settings/connections/applications{/client_id}",
  ...
}

2. Sending URL Parameters in a GET Request

Query parameters are added to a URL to filter or modify the data returned by the server.

Code Example:

import requests

url = "https://api.github.com/search/repositories"
params = {"q": "requests+language:python"}  # Search for Python repositories about "requests"
response = requests.get(url, params=params)

print("Request URL:", response.url)
print("Total Repositories Found:", response.json().get("total_count"))

Explanation:

1. params:

Used to pass query parameters as a dictionary.
Converts {"q": "requests+language:python"} to ?q=requests+language:python and appends it to the URL.

2. response.url:

Outputs the final URL with parameters:

https://api.github.com/search/repositories?q=requests+language:python

3. response.json():

Parses the JSON response into a Python dictionary.
total_count gives the total number of repositories matching the query.

Output:

Request URL: https://api.github.com/search/repositories?q=requests+language:python
Total Repositories Found: 230

3. Making a POST Request

A POST request is used to send data to a server, such as submitting forms.

Code Example:

import requests

url = "https://httpbin.org/post"
data = {"username": "test_user", "password": "test_pass"}
response = requests.post(url, data=data)

print("Response JSON:", response.json())

Explanation:

1. data:

Sends form data as a dictionary in the body of the request.

2. response.json():

Parses the JSON response from the server.
The server at https://httpbin.org/post echoes back the data you send,

Output:

Response JSON: {
  "args": {},
  "data": "",
  "files": {},
  "form": {
    "password": "test_pass",
    "username": "test_user"
  },
  'headers': {'Accept': '*/*', 'Accept-Encoding': 'gzip, deflate', 'Content-Length': '37', 'Content-Type': 'application/x-www-form-urlencoded', 'Host': 'httpbin.org', 'User-Agent': 'python-requests/2.32.3', 'X-Amzn-Trace-Id': 'Root=1-6778c520-3c1dde5b75a7d2900d9b00cb'}, 
 'json': None, 
 'origin': 'xxx', 
 'url': 'https://httpbin.org/post'}

}

4. Downloading a File

You can use the requests library to download files like images, PDFs, or other content.

Code Example:

import requests

url = "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf"
response = requests.get(url)

with open("dummy.pdf", "wb") as file:
    file.write(response.content)
print("File downloaded successfully!")

Explanation:

1. response.content:

Returns the binary content of the file (e.g., for PDFs or images).

2. Writing to a file:

Saves the content to dummy.pdf in the current directory using wb (write binary mode).

Output:

File downloaded successfully!

A file named dummy.pdf will be saved in your current directory.

5. Handling Errors and Timeouts

When dealing with external servers, requests might fail. It’s important to handle such errors gracefully.

Code Example:

import requests

url = "https://api.github.com/nonexistent"

try:
    response = requests.get(url, timeout=5)  # Timeout after 5 seconds
    response.raise_for_status()  # Raise an exception for HTTP errors
    print("Response:", response.json())
except requests.exceptions.Timeout:
    print("The request timed out!")
except requests.exceptions.HTTPError as err:
    print("HTTP error occurred:", err)
except requests.exceptions.RequestException as err:
    print("Other error occurred:", err)

Explanation:

Timeout: Limits how long the program waits for a response.
raise_for_status(): Throws an exception for HTTP errors like 404.
Error Handling: Categorizes errors (e.g., timeout, HTTP errors) for better debugging.

Output (Example for a 404 Error):

HTTP error occurred: 404 Client Error: Not Found for url: https://api.github.com/nonexistent

6. Working with JSON Data

You can send JSON data in a POST request and receive JSON responses.

Code Example:

import requests

url = "https://httpbin.org/post"
json_data = {"key": "value", "name": "Python Requests"}
response = requests.post(url, json=json_data)

print("Response JSON:", response.json())

Explanation:

1. json: Automatically converts the dictionary to JSON format and sets the Content-Type header to application/json.

2. Response: The server echoes the JSON data you send.

Output:

Response JSON: {
  "args": {},
  "data": '{"key": "value1", "name": "Python Requests1"}'
  "files": {},
  "form": {},
  "headers": {
    ...
  },
  "json": {
    "key": "value",
    "name": "Python Requests"
  },
  "url": "https://httpbin.org/post"
}

The requests library is a powerful and easy-to-use tool for making HTTP requests in Python. It covers a wide range of use cases, such as:

Fetching data from APIs (GET requests).
Sending data to servers (POST requests).
Handling errors and timeouts.
Downloading files or automating tasks like form submissions.

What Next?

Explore advanced topics like authentication (BasicAuth, OAuth).
Use APIs like OpenWeatherMap, Twitter, or GitHub to practice.
Learn web scraping with requests + BeautifulSoup.

cpp_005_Introduction to Strings

codeaddict — Wed, 1 Jan 2025 16:20:14 +0900

C++ provides two primary ways to work with strings: C-style strings and the modern std::string class. This tutorial covers the key concepts, differences, and practical examples.

1. What Are Strings in C++?

A string is a sequence of characters. In C++, you can represent strings in two ways:

C-style strings: Arrays of characters ending with a null character (\0).
std::string: A part of the C++ Standard Library, providing an easier and safer way to work with strings.

2. C-Style Strings

C-style strings are simply arrays of characters terminated with a null character (\0). You need to manage their size manually.

Code Example:

#include <iostream>
#include <cstring> // For C-style string functions
using namespace std;

int main() {
    char cstr[] = "Hello, C-style strings!";
    cout << "C-Style String: " << cstr << endl;

    // String length using strlen()
    cout << "Length: " << strlen(cstr) << endl;

    // Concatenation using strcat()
    char greeting[50] = "Hello";
    strcat(greeting, ", World!");
    cout << "Concatenated String: " << greeting << endl;

    return 0;
}

Output:

C-Style String: Hello, C-style strings!
Length: 22
Concatenated String: Hello, World!

Key Points:

strlen(cstr): Returns the number of characters (excluding \0).
strcat(): Concatenates strings but requires enough space in the destination array.

3. std::string Class

std::string is a modern and more versatile way to work with strings. It automatically manages memory and provides many useful functions.

3.1 Declaring and Initializing Strings

If you don’t assign a value to a string, it’s blank (empty) by default.

Code Example:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string str1 = "Hello, ";
    string str2 = "std::string!";
    string emptyStr; // Default value is blank

    cout << "String 1: " << str1 << endl;
    cout << "String 2: " << str2 << endl;
    cout << "Empty String: '" << emptyStr << "'" << endl;

    return 0;
}

Output:

String 1: Hello, 
String 2: std::string!
Empty String: ''

3.2 Length of a String

You can use the .length() or .size() methods to find the length of a string.

Code Example:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string str = "Hello, World!";
    cout << "String: " << str << endl;
    cout << "Length: " << str.length() << endl;

    return 0;
}

Output:

String: Hello, World!
Length: 13

3.3 String Concatenation

Strings can be concatenated using the + operator.

Code Example:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string str1 = "C++ ";
    string str2 = "is fun!";
    string result = str1 + str2;

    cout << "Concatenated String: " << result << endl;

    return 0;
}

Output:

Concatenated String: C++ is fun!

3.4 Modifying Strings

You can modify std::string easily with various operations.

Code Example:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string str = "Hello, C++!";
    str[7] = 'W'; // Replace 'C' with 'W'
    str.append(" Strings are cool!"); // Append to the string

    cout << "Modified String: " << str << endl;

    return 0;
}

Output:

Modified String: Hello, W++! Strings are cool!

3.5 Comparing Strings

You can compare two strings using relational operators.

Code Example:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string str1 = "Apple";
    string str2 = "Banana";

    if (str1 < str2) {
        cout << str1 << " comes before " << str2 << " alphabetically." << endl;
    } else {
        cout << str1 << " comes after " << str2 << " alphabetically." << endl;
    }

    return 0;
}

Output:

Apple comes before Banana alphabetically.

3.6 Finding Substrings

The find() method locates a substring within a string.

Code Example:

In this example, we are using the find() method to locate a substring within a string.

#include <iostream>
#include <string>
using namespace std;

int main() {
    string str = "C++ programming is fun!";
    size_t position = str.find("programming");

    if (position != string::npos) {
        cout << "'programming' found at position: " << position << endl;
    } else {
        cout << "'programming' not found!" << endl;
    }

    return 0;
}

Explanation

str.find("programming") searches for the first occurrence of the substring "programming" in the string str.

string::npos is a constant in the C++ Standard Library, representing an invalid position.

-The function returns the index (position) where the substring begins in the string, or it returns string::npos if the substring is not found.

If find() does not find the substring, it returns string::npos, which is typically a very large number (usually -1 as an unsigned integer).

position != string::npos checks if the substring was found. If it wasn't found, the value of position will be string::npos.

size_t position stores the result. The type size_t is an unsigned integer type, which is used for sizes and positions in C++.

If the substring is found, the position where it starts is printed. The position is 4 in this case because the substring "programming" begins at index 4 of the string "C++ programming is fun!".

Output:

'programming' found at position: 4

Conclusion

In this tutorial, we explored:

C-style strings and their limitations.
The versatile std::string class, including common methods like .length(), concatenation, and substring searching.
The fact that uninitialized std::string variables are blank by default.

For more advanced string manipulation functions, refer to the C++ String Documentation.

cpp_004_Introduction to Math Functions

codeaddict — Wed, 1 Jan 2025 15:24:18 +0900

C++ provides a wide range of math functions to perform calculations efficiently.

1. Basic Arithmetic Operations

C++ supports standard arithmetic operations such as addition, subtraction, multiplication, and division.

Code Example:

#include <iostream>
using namespace std;

int main() {
    int a = 10, b = 3;
    cout << "Addition: " << a + b << endl;
    cout << "Subtraction: " << a - b << endl;
    cout << "Multiplication: " << a * b << endl;
    cout << "Division: " << a / b << endl;  // Integer division
    cout << "Modulus: " << a % b << endl;   // Remainder
    return 0;
}

Output:

Addition: 13
Subtraction: 7
Multiplication: 30
Division: 3
Modulus: 1

Explanation:

Division: Since a and b are integers, the division result is truncated to an integer.
Modulus: The % operator gives the remainder of the division (10 divided by 3 leaves a remainder of 1).

Explanation:

Division: Since a and b are integers, the division result is truncated to an integer.
Modulus: The % operator gives the remainder of the division (10 divided by 3 leaves a remainder of 1).

2. Trigonometric Functions

Trigonometric functions like sin, cos, and tan are used for angle calculations. M_PI (π) is a predefined constant in <cmath>.

Code Example:

#include <iostream>
#include <cmath>
using namespace std;

int main() {
    double angle = M_PI / 6;  // 30 degrees in radians
    cout << "sin(30°): " << sin(angle) << endl;
    cout << "cos(30°): " << cos(angle) << endl;
    cout << "tan(30°): " << tan(angle) << endl;
    return 0;
}

Output:

sin(30°): 0.5
cos(30°): 0.866025
tan(30°): 0.57735

Explanation:

Input: The angle is given in radians (not degrees). M_PI/6 corresponds to 30°.
Outputs: These are the standard trigonometric values for 30°:
sin(30°) = 0.5
cos(30°) ≈ 0.866025
tan(30°) ≈ 0.57735

3. Explanation of M_PI

M_PI is a predefined constant in <cmath> that represents the value of π (pi) in mathematics. Its approximate value is 3.141592653589793. If M_PI is not available in some environments, you can define it manually:

#define M_PI 3.141592653589793

4. Square Root and Power

The sqrt function calculates the square root, and pow calculates the power of a number.

Code Example:

#include <iostream>
#include <cmath>
using namespace std;

int main() {
    cout << "Square root of 25: " << sqrt(25) << endl;
    cout << "2^5: " << pow(2, 5) << endl;
    return 0;
}

Output:

Square root of 25: 5
2^5: 32

Explanation:

Square root: sqrt(25) returns 5 because 5×5=25.
Power: pow(2, 5) returns 32 because 2^5 =2×2×2×2×2.

5. Rounding Functions

Functions like ceil, floor, round, and trunc handle decimal numbers differently.

Code Example:

#include <iostream>
#include <cmath>
using namespace std;

int main() {
    double num = 7.65;
    cout << "Ceil: " << ceil(num) << endl;   // Rounds up
    cout << "Floor: " << floor(num) << endl; // Rounds down
    cout << "Round: " << round(num) << endl; // Nearest integer
    cout << "Truncate: " << trunc(num) << endl; // Removes fractional part
    return 0;
}

Output:

Ceil: 8
Floor: 7
Round: 8
Truncate: 7

Explanation:

ceil: Always rounds up (7.65 → 8).
floor: Always rounds down (7.65 → 7).
round: Rounds to the nearest integer (7.65 → 8).
trunc: Removes the fractional part without rounding (7.65 → 7).

6. Min and Max

The fmin and fmax functions find the smallest and largest of two numbers.

Code Example:

#include <iostream>
#include <cmath>
using namespace std;

int main() {
    double x = 5.7, y = 8.2;
    cout << "Minimum: " << fmin(x, y) << endl;
    cout << "Maximum: " << fmax(x, y) << endl;
    return 0;
}

Output:

Minimum: 5.7
Maximum: 8.2

Explanation:

fmin: Returns the smaller value.
fmax: Returns the larger value.

7. Modulus and Remainder

The fmod function calculates the floating-point remainder, while remainder gives the remainder closest to zero.

Code Example:

#include <iostream>
#include <cmath>
using namespace std;

int main() {
    double num1 = 8.75, num2 = 3.4;
    cout << "fmod(8.75, 3.4): " << fmod(num1, num2) << endl;
    cout << "remainder(8.75, 3.4): " << remainder(num1, num2) << endl;
    return 0;
}

Output:

fmod(8.75, 3.4): 1.95
remainder(8.75, 3.4): -1.45

Explanation:

fmod: Computes the remainder after division (8.75 - (2 * 3.4) = 1.95).
remainder: Returns the remainder closest to zero (-1.45). remainder(x,y)=x−(nearest multiple of y)

8. Infinity and NaN

INFINITY represents positive infinity, and NaN (Not a Number) represents undefined results.

Code Example:

#include <iostream>
#include <cmath>
using namespace std;

int main() {
    cout << "Positive Infinity: " << INFINITY << endl;
    cout << "Negative Infinity: " << -INFINITY << endl;

    double invalid = 0.0 / 0.0;
    cout << "NaN: " << invalid << endl;
    return 0;
}

Output:

Positive Infinity: inf
Negative Infinity: -inf
NaN: nan

Explanation:

INFINITY: Represents values that exceed the range of floating-point numbers.
NaN: Results from undefined operations (e.g., dividing 0 by 0).

Conclusion

The functions we covered in this tutorial (like sqrt, pow, fmod, remainder, ceil, floor, etc.) are all part of the C++ Math Library provided in the <cmath> header. These functions help solve common mathematical problems efficiently.

However, the <cmath> library includes many other powerful functions that were not covered here, such as:

Hyperbolic functions: sinh, cosh, tanh, etc.
Exponential and logarithmic functions: exp, log, log10, etc.
Angle conversion: degrees, radians (available in C++20).
More rounding functions: nearbyint, copysign, etc.

For a complete list of all mathematical functions available in <cmath>, you can refer to the official documentation:

Python Intermediate_004_ Guide to PyYAML

codeaddict — Mon, 30 Dec 2024 22:16:20 +0900

Introduction

When dealing with configuration files or structured data, YAML (short for “YAML Ain’t Markup Language”) is a popular format due to its simplicity and readability. YAML organizes data in a human-readable manner with minimal syntax, using indentation and symbols like : for key-value pairs, - for lists, and nesting for hierarchy. In Python, the PyYAML library allows seamless interaction with YAML files for reading and writing structured data.

In this blog post, we will walk through three examples, starting from simple to advanced, showcasing how to read from and write to YAML files using PyYAML. Each example will include clear explanations of the YAML structure and the corresponding Python code.

Prerequisites

Before diving in, ensure you have installed PyYAML. Use the following command to install it via pip:

pip install pyyaml

1. Example1: Reading and Writing a Flat YAML File

Create a YAML File

Create a file named user.yaml in the same directory as your Python script and add the following content:

name: Alice
age: 30
is_developer: true

Code: Reading and Writing

import yaml

# Reading from a YAML file
with open('user.yaml', 'r') as file:
    user_data = yaml.safe_load(file)

print("Loaded YAML Data:", user_data)  # Output: {'name': 'Alice', 'age': 30, 'is_developer': True}

# Writing back to a new YAML file
updated_data = {
    'name': 'Alice',
    'age': 31,  # Update the age
    'is_developer': True
}

with open('updated_user.yaml', 'w') as file:
    yaml.dump(updated_data, file)
print("Updated YAML saved to 'updated_user.yaml'")

Explanation

Reading: The yaml.safe_load() function parses the user.yaml file into a Python dictionary.
Writing: The yaml.dump() function serializes the updated dictionary back into a YAML file.

This approach is ideal for flat YAML files without nested structures.

2. Example2: Handling Nested YAML Data

Create a YAML File

Create a file named config.yaml and add the following content:

server:
  host: localhost
  port: 8000
  debug: true
database:
  name: app_db
  user: admin
  password: secret

Code: Reading and Writing

import yaml

# Reading nested YAML data
with open('config.yaml', 'r') as file:
    config = yaml.safe_load(file)

print("Database Config:", config['database'])  # Output: {'name': 'app_db', 'user': 'admin', 'password': 'secret'}

# Modifying and writing nested YAML data
config['server']['debug'] = False  # Disable debug mode
config['database']['password'] = 'new_secret'  # Update password

with open('updated_config.yaml', 'w') as file:
    yaml.dump(config, file)
print("Updated YAML saved to 'updated_config.yaml'")

Explanation

Reading: Nested YAML structures are directly converted into Python dictionaries containing other dictionaries. Access nested elements using keys.
Modifying: You can update nested keys like config['server']['debug'] to change specific values.
Writing: The modified data is written back into a YAML file, preserving the nested structure.

This method is perfect for hierarchical configurations like server settings or application environments.

3. Example3: Working with Lists in YAML

YAML Context

Now, consider a YAML file named employees.yaml that includes a list of employees:

employees:
  - name: John Doe
    age: 28
    skills:
      - Python
      - Django
  - name: Jane Smith
    age: 35
    skills:
      - JavaScript
      - React

Code: Reading and Writing

import yaml

# Reading YAML with lists
with open('employees.yaml', 'r') as file:
    employees_data = yaml.safe_load(file)

for employee in employees_data['employees']:
    print(f"Employee: {employee['name']}, Skills: {', '.join(employee['skills'])}")

# Adding a new employee to the list
new_employee = {
    'name': 'Alice Green',
    'age': 30,
    'skills': ['Flask', 'SQLAlchemy']
}
employees_data['employees'].append(new_employee)

with open('updated_employees.yaml', 'w') as file:
    yaml.dump(employees_data, file)
print("Updated YAML saved to 'updated_employees.yaml'")

Explanation

Reading: The yaml.safe_load() function reads lists within YAML files as Python lists, allowing iteration.
Processing: Each employee is processed individually, demonstrating how to access nested data within lists.
Writing: A new employee is appended to the employees list, and the updated data is saved back into a YAML file.

This approach is particularly useful for datasets with repetitive structures, such as employee records, product catalogs, or inventory lists.

Conclusion

PyYAML simplifies working with YAML files, whether you’re dealing with flat key-value pairs, nested configurations, or complex lists. By understanding how to read, modify, and write YAML files, you can leverage YAML’s human-readable format for configurations, data storage, or application settings.

Explore PyYAML in your projects to create cleaner, more maintainable configurations — and let YAML handle the structure for you!

codeaddict 님의 블로그

Python Intermediate_016_Encapsulation in Python — Concepts, Examples, and Practical Application

1. Introduction

2. Encapsulation in Python: Public, Protected, and Private

3. Why Encapsulation Matters: A Problem and Solution

Problem: Managing a Budget Tracker

Solution: Encapsulation with Private Members

Python Intermediate_015_ Sorting with .sort() and Lambda in Python

What is .sort() with Lambda?

Syntax:

Examples of Sorting with .sort() and Lambda

Example 1: Sorting a List of Strings Alphabetically

Example 2: Sorting a List of Tuples by the Second Element

Example 3: Sorting Strings by Length

Example 4: Sorting a List of Tuples by Multiple Criteria

Example 5: Sorting in Descending Order

When to Use .sort() with Lambda

Python Intermediate_014: Understanding @staticmethod in Python

1. Regular Methods: Attached to the Class

2. Static Methods vs. Standalone Functions

3. Practical Example: Numbers, No Class Strings Attached

4. Another example

5. So, Why @staticmethod?

Python Intermediate_013: Understanding @classmethod in Python

1. Basic @classmethod Example

Order of Execution

2. Practical Example: Instance Tracker

Order of Execution (for the full test)

3. Why @classmethod Rocks

Bonus Example: Factory Method

Explanation Step by Step

1. What’s Happening When You Call Person.from_string(“Alice-30”)?

2. Inside from_string(cls, data)

3. What data Does in from_string

4. How It All Comes Together

Wrap-Up

Python Intermediate_012:Python’s Magic Methods in Classes(Overview)

1. What Are Magic Methods?

2. Why Use Them?

3. A Quick Tour of Common Magic Methods

__init__(self, …)

__str__(self)

__add__(self, other)

__eq__(self, other)

__len__(self)

4. How They Fit Together

5. What’s Next?

Why the Double Underscores?

How Do You Use Them?

Why Not Just len?

The Big List

Python Intermediate_011: Recursive Functions in Python

1. What Are Recursive Functions?

2. Simple Example: Factorial of a Number

How It Works:

3. Why Use Recursion?

4. More Complex Example: Fibonacci Sequence

How It Works:

5. Problem 1: Power of a Number

Explanation:

6. Problem 2: Binary Search Using Recursion

Explanation:

7. Problem 3: Recursive List Sum

Explanation:

— Key Takeaways

Python Intermediate_010: Inheritance in Python

1. What is super()?

Key Points About super()

2. Example_1: Modeling Shapes with Inheritance

Parent Class: Shape

Child Class: Rectangle

Child Class: Circle

Using the Classes

Explanation of the Shape Example

3. Example_2: Inheritance with Numeric Calculations

Parent Class: Calculator

Child Class: AdvancedCalculator

Using the Classes

Explanation of the Calculator Example

- Why super() Wasn’t Used in AdvancedCalculator

init(self, …)

str(self)

add(self, other)

eq(self, other)

len(self)