DEV Community: Bhagyashree

Daily Python Practice: Bridging the Gap Between Learner and Pro

Bhagyashree — Thu, 11 Jun 2026 15:33:11 +0000

Python Programs to Practice

1) Print: 1 1 1 1 1

Concept

Printing the same value repeatedly.

Logic

Use a loop to print 1 five times.

Algorithm

Start
Repeat 5 times
Print 1
Stop

Flowchart

                        ┌─────────┐
                        │  START  │
                        └────┬────┘
                             │
                      ┌──────▼──────┐
                      │ count = 1   │
                      └──────┬──────┘
                             │
                      ┌──────▼──────┐
                      │ count <= 5? │
                      └───┬────┬────┘
                        Yes    No
                          │    │
                          │    ▼
                          │  ┌───────┐
                          │  │  END  │
                          │  └───────┘
                          │
                    ┌─────▼─────┐
                    │ Print 1   │
                    └─────┬─────┘
                          │
                    ┌─────▼─────┐
                    │count+=1   │
                    └─────┬─────┘
                          │
                          └───────────► Back to Decision

Python Code

count = 1

while count <= 5:
    print(1, end=" ")
    count += 1

Result

2) Print: 1 2 3 4 5

Concept

Natural numbers.

Logic

Print numbers from 1 to 5.

Algorithm

Start
Loop from 1 to 5
Print number
Stop

Flowchart

                          START
                            │
                            ▼
                        ┌─────────┐
                        │ num = 1 │
                        └────┬────┘
                             │
                             ▼
                        ┌──────────┐
                        │num <= 5 ?│
                        └──┬────┬──┘
                        Yes│    │No
                           │    ▼
                           │  END
                           │
                           ▼
                        ┌──────────┐
                        │Print num │
                        └────┬─────┘
                             │
                             ▼
                        ┌──────────┐
                        │ num+=1   │
                        └────┬─────┘
                             │
                             └──────► Back to Decision

Python Code

num = 1

while num <= 5:
    print(num, end=" ")
    num += 1

Result

3) Print: 1 3 5 7 9

Concept

Odd numbers.

Logic

Increase by 2 each time.

Formula

Odd Number = 2n - 1

Algorithm

Start
Loop from 1 to 9 with step 2
Print
Stop

Flowchart

                      START
                        │
                        ▼
                    ┌─────────┐
                    │ num = 1 │
                    └────┬────┘
                         │
                         ▼
                    ┌──────────┐
                    │num <= 9 ?│
                    └──┬────┬──┘
                    Yes│    │No
                       │    ▼
                       │   END
                       │
                       ▼
                    ┌──────────┐
                    │Print num │
                    └────┬─────┘
                         │
                         ▼
                    ┌──────────┐
                    │ num+=2   │
                    └────┬─────┘
                         │
                         └────► Back to Decision

Python Code

num = 1

while num <= 9:
    print(num, end=" ")
    num += 2

Result

4) Print: 3 6 9 12 15

Concept

Multiples of 3.

Formula

Multiple = 3 × n

Algorithm

Start
Multiply numbers 1 to 5 by 3
Print
Stop

Flowchart

                       START
                         │
                         ▼
                    ┌─────────┐
                    │ num = 3 │
                    └────┬────┘
                         │
                         ▼
                    ┌───────────┐
                    │num <= 15 ?│
                    └──┬─────┬──┘
                    Yes│     │No
                       │     ▼
                       │    END
                       │
                       ▼
                    ┌──────────┐
                    │Print num │
                    └────┬─────┘
                         │
                         ▼
                    ┌──────────┐
                    │ num+=3   │
                    └────┬─────┘
                         │
                         └────► Back to Decision

Python Code

num = 3

while num <= 15:
    print(num, end=" ")
    num += 3

Result

4.1) Print: 15 12 9 6 3

Logic

Reverse multiples of 3.

Algorithm

Step 1: Start
Step 2: Initialize num = 15
Step 3: Repeat while num ≥ 3
Step 4: Print num
Step 5: num = num - 3
Step 6: Repeat Step 3
Step 7: Stop

Flowchart

                    ┌─────────┐
                    │ START   │
                    └────┬────┘
                         │
                         ▼
                    ┌────────────┐
                    │ num = 15   │
                    └─────┬──────┘
                          │
                          ▼
                    ┌─────────────┐
                    │ num >= 3 ?  │
                    └───┬─────┬───┘
                        Yes    No
                        │      │
                        │      ▼
                        │   ┌──────┐
                        │   │ END  │
                        │   └──────┘
                        │
                        ▼
                ┌─────────────┐
                │ Print num   │
                └─────┬───────┘
                      │
                      ▼
                ┌─────────────┐
                │ num = num-3 │
                └─────┬───────┘
                      │
                      └──────────► Back to Decision

Python Code

num = 15

while num >= 3:
    print(num, end=" ")
    num -= 3

Result

4.2) Print: 10 8 6 4 2

Concept

Reverse even numbers.

Formula

Even Number = 2n

Algorithm

Step 1: Start
Step 2: Initialize num = 10
Step 3: Repeat while num ≥ 2
Step 4: Print num
Step 5: num = num - 2
Step 6: Repeat Step 3
Step 7: Stop

Flowchart

                    ┌─────────┐
                    │ START   │
                    └────┬────┘
                         │
                         ▼
                    ┌────────────┐
                    │ num = 10   │
                    └─────┬──────┘
                          │
                          ▼
                    ┌─────────────┐
                    │ num >= 2 ?  │
                    └───┬─────┬───┘
                        Yes    No
                        │      │
                        │      ▼
                        │   ┌──────┐
                        │   │ END  │
                        │   └──────┘
                        │
                        ▼
                ┌─────────────┐
                │ Print num   │
                └─────┬───────┘
                      │
                      ▼
                ┌─────────────┐
                │ num = num-2 │
                └─────┬───────┘
                      │
                      └──────────► Back to Decision

Python Code

num = 10

while num >= 2:
    print(num, end=" ")
    num -= 2

Result

4.3) Print: 9 7 5 3 1

Concept

Reverse odd numbers.

Algorithm

Step 1: Start
Step 2: Initialize num = 9
Step 3: Repeat while num ≥ 1
Step 4: Print num
Step 5: num = num - 2
Step 6: Repeat Step 3
Step 7: Stop

Flowchart

                        ┌─────────┐
                        │ START   │
                        └────┬────┘
                             │
                             ▼
                        ┌────────────┐
                        │ num = 9    │
                        └─────┬──────┘
                              │
                              ▼
                        ┌─────────────┐
                        │ num >= 1 ?  │
                        └───┬─────┬───┘
                            Yes    No
                            │      │
                            │      ▼
                            │   ┌──────┐
                            │   │ END  │
                            │   └──────┘
                            │
                            ▼
                    ┌─────────────┐
                    │ Print num   │
                    └─────┬───────┘
                          │
                          ▼
                    ┌─────────────┐
                    │ num = num-2 │
                    └─────┬───────┘
                          │
                          └──────────► Back to Decision

Python Code

num = 9

while num >= 1:
    print(num, end=" ")
    num -= 2

Result

5) Multiples of 3 and 5

Concept

Numbers divisible by both 3 and 5.

Formula

n % 3 == 0 and n % 5 == 0

Algorithm

Read limit
Check each number
Print if divisible by both

Flowchart

                     START
                       │
                       ▼
                    ┌─────────┐
                    │ num = 1 │
                    └────┬────┘
                         │
                         ▼
                    ┌────────────┐
                    │num <= 100 ?│
                    └──┬──────┬──┘
                    Yes│      │No
                       │      ▼
                       │     END
                       │
                       ▼
                    ┌────────────────────┐
                    │num%3==0 AND        │
                    │num%5==0 ?          │
                    └──┬─────────────┬───┘
                    Yes│             │No
                       │             │
                       ▼             │
                    ┌──────────┐     │
                    │Print num │     │
                    └────┬─────┘     │
                         │           │
                         └────┬──────┘
                              ▼
                        ┌──────────┐
                        │ num+=1   │
                        └────┬─────┘
                             │
                             └────► Back to Decision

Python Code

num = 1

while num <= 100:
    if num % 3 == 0 and num % 5 == 0:
        print(num, end=" ")
    num += 1

Result (n=50)

6) Multiples of 3 or 5

Formula

n % 3 == 0 or n % 5 == 0

Algorithm

Step 1: Start
Step 2: Input n
Step 3: Initialize i = 1
Step 4: Repeat while i ≤ n
Step 5: If i % 3 == 0 OR i % 5 == 0, print i
Step 6: Increment i by 1
Step 7: Repeat Step 4
Step 8: Stop

Flowchart

                ┌─────────┐
                │ START   │
                └────┬────┘
                     │
                     ▼
             ┌─────────────┐
             │ Input n     │
             └──────┬──────┘
                    │
                    ▼
             ┌─────────────┐
             │ i = 1       │
             └──────┬──────┘
                    │
                    ▼
             ┌─────────────┐
             │ i <= n ?    │
             └───┬─────┬───┘
                Yes    No
                 │      │
                 │      ▼
                 │   ┌──────┐
                 │   │ END  │
                 │   └──────┘
                 │
                 ▼
      ┌──────────────────────────┐
      │ i % 3 == 0 OR i % 5 ==0 ?│
      └──────┬─────────────┬─────┘
            Yes            No
             │              │
             ▼              │
      ┌─────────────┐       │
      │ Print i     │       │
      └──────┬──────┘       │
             │              │
             └──────┬───────┘
                    ▼
             ┌─────────────┐
             │ i = i + 1   │
             └──────┬──────┘
                    │
                    └──────────► Back to (i <= n ?)

Python Code

n = int(input("Enter limit: "))

for i in range(1, n + 1):
    if i % 3 == 0 or i % 5 == 0:
        print(i, end=" ")

Result (n=20)

7) Divisors of Given Number

Concept

Numbers that divide perfectly.

Formula

n % i == 0

Algorithm

Read number
Check 1 to n
Print divisors

Flowchart

                ┌─────────┐
                │ START   │
                └────┬────┘
                     │
                     ▼
             ┌─────────────┐
             │ Input n     │
             └──────┬──────┘
                    │
                    ▼
             ┌─────────────┐
             │ i = 1       │
             └──────┬──────┘
                    │
                    ▼
             ┌─────────────┐
             │ i <= n ?    │
             └───┬─────┬───┘
                Yes    No
                 │     │
                 │     ▼
                 │   ┌──────┐
                 │   │ END  │
                 │   └──────┘
                 │
                 ▼
           ┌─────────────┐
           │ n % i == 0? │
           └───┬─────┬───┘
              Yes    No
               │      │
               ▼      │
         ┌─────────┐  │
         │ Print i │  │
         └────┬────┘  │
              │       │
              └───┬───┘
                  ▼
           ┌─────────┐
           │ i = i+1 │
           └────┬────┘
                │
                └────────► Back to (i <= n ?)

Python Code

n = int(input("Enter number: "))

for i in range(1, n + 1):
    if n % i == 0:
        print(i, end=" ")

Result

8) Count of Divisors

Concept

Count total divisors.

Algorithm

Step 1: Start
Step 2: Input n
Step 3: Initialize i = 1 and count = 0
Step 4: Repeat while i ≤ n
Step 5: If n % i == 0, increment count by 1
Step 6: Increment i by 1
Step 7: Repeat Step 4
Step 8: Print count
Step 9: Stop

Flowchart

                        START
                           │
                           ▼
                    ┌────────────┐
                    │ Input n    │
                    └────┬───────┘
                         │
                         ▼
                    ┌─────────────────┐
                    │ i=1, count=0    │
                    └────┬────────────┘
                         │
                         ▼
                    ┌──────────┐
                    │ i <= n ? │
                    └──┬────┬──┘
                    Yes│     │No
                       │    ▼
                       │ ┌──────────┐
                       │ │PrintCount│
                       │ └────┬─────┘
                       │      │
                       │     END
                       │
                       ▼
                    ┌────────────┐
                    │ n%i == 0 ? │
                    └──┬─────┬───┘
                    Yes│     │No
                       │     │
                       ▼     │
                    ┌───────────┐
                    │count+=1   │
                    └────┬──────┘
                        │
                        ▼
                    ┌──────────┐
                    │ i = i+1  │
                    └────┬─────┘
                         │
                         └────► Back to Decision

Python Code

n = int(input("Enter number: "))
i = 1
count = 0

while i <= n:
    if n % i == 0:
        count += 1
    i += 1

print("Count =", count)

Result

9) Prime Number

Concept

Exactly two divisors.

Formula

Count of divisors = 2

Algorithm

Count divisors
If count=2 → Prime

Flowchart

                      START
                        │
                        ▼
                    ┌────────────┐
                    │ Input n    │
                    └────┬───────┘
                         │
                         ▼
                    ┌─────────────────┐
                    │i=1,count=0      │
                    └────┬────────────┘
                         │
                         ▼
                    ┌──────────┐
                    │ i <= n ? │
                    └──┬────┬──┘
                    Yes│    │No
                        │    ▼
                        │ ┌────────────┐
                        │ │count == 2 ?│
                        │ └──┬─────┬───┘
                        │ Yes│     │No
                        │    │     │
                        │    ▼     ▼
                        │ Prime  Not Prime
                        │    │     │
                        │    └──┬──┘
                        │       ▼
                        │      END
                        │
                        ▼
                        ┌────────────┐
                        │ n%i == 0 ? │
                        └──┬─────┬───┘
                        Yes│     │No
                           │     │
                           ▼     ▼
                        ┌──────────┐
                        │count+=1  │
                        └────┬─────┘
                             ▼
                        ┌──────────┐
                        │ i = i+1  │
                        └────┬─────┘
                             │
                             └────► Back to Decision

Python Code

n = int(input("Enter number: "))

i = 1
count = 0

while i <= n:
    if n % i == 0:
        count += 1
    i += 1

if count == 2:
    print("Prime Number")
else:
    print("Not Prime Number")

Result

10) Perfect Number

Concept

Sum of proper divisors equals the number.

Formula

Sum(divisors except itself) = n

Example:

6 = 1 + 2 + 3

Algorithm

Step 1: Start
Step 2: Input n
Step 3: Initialize i = 1 and total = 0
Step 4: Repeat while i < n
Step 5: If n % i == 0, add i to total
Step 6: Increment i by 1
Step 7: Repeat Step 4
Step 8: If total == n, print "Perfect Number"
Step 9: Else print "Not Perfect Number"
Step 10: Stop

Flowchart

                       START
                        │
                        ▼
                    ┌────────────┐
                    │ Input n    │
                    └────┬───────┘
                         │
                         ▼
                    ┌─────────────────┐
                    │i=1,total=0      │
                    └────┬────────────┘
                         │
                         ▼
                    ┌──────────┐
                    │ i < n ?  │
                    └──┬────┬──┘
                    Yes│    │No
                       │    ▼
                       │ ┌────────────┐
                       │ │ total==n ? │
                       │ └──┬─────┬───┘
                       │ Yes│     │No
                       │    ▼     ▼
                       │ Perfect Not Perfect
                       │    │      │
                       │    └──┬───┘
                       │       ▼
                       │      END
                       │
                       ▼
                    ┌────────────┐
                    │ n%i == 0 ? │
                    └──┬─────┬───┘
                    Yes│     │No
                       │     │
                       ▼     ▼
                    ┌──────────┐
                    │total+=i  │
                    └────┬─────┘
                         ▼
                    ┌──────────┐
                    │ i = i+1  │
                    └────┬─────┘
                         │
                         └────► Back to Decision

Python Code

n = int(input("Enter number: "))

i = 1
total = 0

while i < n:
    if n % i == 0:
        total += i
    i += 1

if total == n:
    print("Perfect Number")
else:
    print("Not Perfect Number")

Result

11) Print 1 3 5 7 9 2 4 6 8 10 in Single Loop

Logic

Print odds first, then evens using one loop.

Algorithm

First five iterations → odd numbers
Next five iterations → even numbers

Flowchart

                    ┌─────────┐
                    │ START   │
                    └────┬────┘
                         │
                         ▼
                    ┌──────────┐
                    │ i = 1    │
                    └────┬─────┘
                         │
                         ▼
                    ┌──────────┐
                    │ i <= 10 ?│
                    └──┬─────┬─┘
                    Yes│     │No
                       │     ▼
                       │    END
                       │
                       ▼
            ┌──────────────────────┐
            │ i <= 5 ?             │
            └──────┬────────────┬──┘
                Yes│            │No
                   │            │
                   ▼            ▼
        ┌─────────────────┐   ┌─────────────────┐
        │ Print 2*i-1     │   │ Print 2*(i-5)   │
        └──────┬──────────┘   └──────┬──────────┘
               │                     │
               └──────┬──────────────┘
                      ▼
               ┌──────────┐
               │ i = i+1  │
               └────┬─────┘
                    │
                    └────► Back to Decision (i <= 10 ?)

Python Code

i = 1

while i <= 10:
    if i <= 5:
        print(2 * i - 1, end=" ")
    else:
        print(2 * (i - 5), end=" ")
    i += 1

Result

12) Factorial of Given Number

Concept

Product of numbers from 1 to n.

Formula

n! = n × (n − 1) × (n − 2) × ... × 2 × 1
Special case:
0! = 1

Example

5! = 120

Algorithm

fact=1
Multiply 1 to n
Print fact

Flowchart

                    ┌─────────┐
                    │ START   │
                    └────┬────┘
                         │
                         ▼
                    ┌────────────┐
                    │ Input n    │
                    └────┬───────┘
                         │
                         ▼
                    ┌─────────────────┐
                    │ fact=1, i=1     │
                    └────┬────────────┘
                         │
                         ▼
                    ┌──────────┐
                    │ i <= n ? │
                    └──┬─────┬──┘
                    Yes│     │No
                       │     ▼
                       │    END
                       │
                       ▼
                    ┌──────────┐
                    │ fact *= i│
                    └────┬─────┘
                         │
                         ▼
                    ┌──────────┐
                    │ i = i+1  │
                    └────┬─────┘
                         │
                         └────► Back to Decision (i <= n ?)

Python Code

n = int(input("Enter number: "))

fact = 1
i = 1

while i <= n:
    fact *= i
    i += 1

print("Factorial =", fact)

Result

13) Sum of First n Numbers

Concept

Addition of natural numbers.

Formula

Sum = n(n + 1) / 2

Algorithm

Read n
Add 1 to n
Print sum

Flowchart

                       START
                        │
                        ▼
                    ┌────────────┐
                    │ Input n    │
                    └────┬───────┘
                         │
                         ▼
                    ┌────────────────┐
                    │i=1,total=0     │
                    └────┬───────────┘
                         │
                         ▼
                    ┌──────────┐
                    │ i <= n ? │
                    └──┬────┬──┘
                    Yes│    │No
                       │    ▼
                       │ ┌──────────┐
                       │ │Print Sum │
                       │ └────┬─────┘
                       │      │
                       │     END
                       │
                       ▼
                    ┌──────────┐
                    │total+=i  │
                    └────┬─────┘
                         ▼
                    ┌──────────┐
                    │ i=i+1    │
                    └────┬─────┘
                         │
                         └────► Back to Decision (i <= n ?)

Python Code

n = int(input("Enter number: "))

i = 1
total = 0

while i <= n:
    total += i
    i += 1

print("Sum =", total)

Result

14) Print First 5 Prime Numbers

Concept

Generate prime numbers until 5 are found.

Logic

Check each number for primality.

Algorithm

Step 1: Start
Step 2: Initialize no = 2 and prime_count = 0
Step 3: Repeat while prime_count < 5
Step 4: Check whether no is prime
Step 5: If prime, print no and increment prime_count
Step 6: Increment no by 1
Step 7: Go to Step 3
Step 8: Stop

Flowchart

                          START
                            │
                            ▼
                    ┌────────────────────┐
                    │ no=2, count=0      │
                    └─────────┬──────────┘
                              │
                              ▼
                    ┌──────────────────┐
                    │ count < 5 ?      │
                    └─────┬────────┬───┘
                       Yes│        │No
                          │        ▼
                          │       END
                          ▼
                    ┌──────────────────┐
                    │ find_prime(no) ? │
                    └─────┬────────┬───┘
                       Yes│        │No
                          ▼        │
                    ┌───────────┐  │
                    │ Print no  │  │
                    └─────┬─────┘  │
                          ▼        │
                    ┌───────────┐  │
                    │count+=1   │  │
                    └─────┬─────┘  │
                          └──┬─────┘
                             ▼
                    ┌───────────┐
                    │ no = no+1 │
                    └─────┬─────┘
                          │
                          └────► Back to Decision (count < 5 ?)

Python Code

no = 2
prime_count = 0
while prime_count < 5:
    result = find_prime(no)
    if result:
        print(no, end=" ") 
        prime_count+=1
    no+=1

Result

15) Sum of First 5 Prime Numbers

Concept

Generate the first five prime numbers and add them.

Formula

2 + 3 + 5 + 7 + 11 = 28

Algorithm

Initialize sum = 0
Find prime numbers
Stop after 5 primes
Print sum

Flowchart

                      START
                        │
                        ▼
                    ┌────────────────────┐
                    │ no=2, count=0      │
                    └─────────┬──────────┘
                              │
                              ▼
                    ┌──────────────────┐
                    │ count < 5 ?      │
                    └─────┬────────┬───┘
                       Yes│        │No
                          │        ▼
                          │       END
                          ▼
                    ┌──────────────────┐
                    │ find_prime(no) ? │
                    └─────┬────────┬───┘
                       Yes│        │No
                          ▼        │
                    ┌───────────┐  │
                    │ Print no  │  │
                    └─────┬─────┘  │
                          ▼        │
                    ┌───────────┐  │
                    │count+=1   │  │
                    └─────┬─────┘  │
                          └──┬─────┘
                             ▼
                    ┌───────────┐
                    │ no = no+1 │
                    └─────┬─────┘
                          │
                          └────► Back to Decision (count < 5 ?)

Python Code

count = 0
total_sum = 0
num = 2

while count < 5:
    i = 2
    while i < num and num % i != 0:
        i += 1

    if i == num:
        total_sum += num
        count += 1

    num += 1

print("Sum =", total_sum)

Result

Formula Revision Table

Program	Formula/Idea
Same number	Repeat constant value
Natural numbers	`i`
Odd numbers	`2n - 1`
Even numbers	`2n`
Multiples of 3	`3 × n`
Multiples of 5	`5 × n`
Divisor	`n % i == 0`
Prime	Exactly 2 divisors
Perfect	Sum of proper divisors = number
Factorial	`n! = 1×2×...×n`
Sum of first n numbers	`n(n+1)/2`
First 5 primes	`2, 3, 5, 7, 11`
Sum of first 5 primes	`28`

Working with Numbers in Python: Extraction, Sum, and Product Concepts

Bhagyashree — Thu, 11 Jun 2026 15:30:35 +0000

INTRODUCTION

🔹 1) Concept of Digit Extraction using Modulo and Division

These programs are based on number manipulation techniques in Python using:

% (modulus operator) → gives remainder
// (floor division) → removes digits from a number

👉 Example:

1234 % 100 = 34 → last 2 digits
1234 // 100 = 12 → first 2 digits

This concept is used to split numbers into parts without converting them into strings.

🔹 2) Concept of While Loop in Number Processing

All programs use a while loop, which is used when the number of iterations is not fixed.

Structure:

while condition:
    statements

Purpose in these tasks:

Repeatedly extract digits
Reduce the number step-by-step
Stop when number becomes 0 or condition fails

🔹 3) Concept of Pattern Formation in Numbers

These tasks are based on creating patterns like:

Examples:

1234 → 34 23 12
1234 → 34 12
123456 → 456 123

This is done by:

Changing how many digits are removed each time (// 10, // 100, // 1000)
Controlling overlapping or non-overlapping digit groups

🔹 4) Concept of Sum of Extracted Values

In sum-based tasks:

Idea:

Instead of printing values, we accumulate them in a variable

sum = sum + extracted_value

Working:

Extract number using %
Add it to sum
Reduce number using //

🔹 5) Concept of Product of Extracted Values

Same logic as sum, but using multiplication:

Idea:

product = product * extracted_value

Important:

Initial value must be 1
Used for cumulative multiplication of extracted digits

🔹 6) Concept of Overlapping vs Non-Overlapping Extraction

🔸 Overlapping extraction:

Uses // 10

Example:

1234 → 34 → 23 → 12

👉 digits overlap

🔸 Non-overlapping extraction:

Uses // 100 or // 1000

Example:

1234 → 34 → 12

👉 digits do NOT overlap

🔹 7) Concept of Splitting Large Numbers

Example:

123456 → 456 123

Logic:

% 1000 → last 3 digits
// 1000 → first 3 digits

This is useful in:

ID processing
roll numbers
data segmentation

Task-1 : Print 34 23 12

Concept

The program extracts and prints the last two digits of a number using the modulo operator (% 100). After printing, it removes only the last digit using integer division (// 10). This creates overlapping two-digit groups.

no % 100 prints the last two digits.
no // 10 removes only the last digit, allowing the next overlapping pair to be formed.

For 1234:

First iteration → 34
Second iteration → 23
Third iteration → 12

Algorithm

Start.
Assign no = 1234.
Check whether no >= 10.
If true:

Print no % 100.
Update no = no // 10.
1. Repeat Step 3 until no < 10.
2. Stop.

Flowchart

 ┌───────┐
 │ Start │
 └───┬───┘
     │
     ▼
 ┌──────────┐
 │ no=1234  │
 └────┬─────┘
      │
      ▼
 ┌──────────┐
 │ no >= 10 │───────
 └───┬──────┘      │
    Yes            No
     │             │
     ▼             ▼
┌────────────┐  ┌──────┐
│Print no%100│  │ Stop │
└─────┬──────┘  └──────┘
      │
      ▼
┌───────────┐
│no=no//10  │
└─────┬─────┘
      │
      └──────────► Back to Condition

Program

no = 1234

while no >= 10:
    print(no % 100,end=" ")
    no = no // 10

🔄 Execution Table

Iteration [3, 4, 5, 6, 7]	Loop Condition (no >= 10)	Execution Step	Operation	Result / Output
Start	Initial Value	Set starting number	no = 1234	no is 1234
Loop 1	1234 >= 10 (True)	1. Print statement	1234 % 100	Prints 34
		2. Floor division	1234 // 10	no becomes 123
Loop 2	123 >= 10 (True)	1. Print statement	123 % 100	Prints 23
		2. Floor division	123 // 10	no becomes 12
Loop 3	12 >= 10 (True)	1. Print statement	12 % 100	Prints 12
		2. Floor division	12 // 10	no becomes 1
End	1 >= 10 (False)	Loop terminates	Exit loop	Program finishes successfully

Trace Table

Iteration	no (Before)	no % 100	Output	no = no // 10
1	1234	34	34	123
2	123	23	23	12
3	12	12	12	1

Output

Task-2 : Print 34 12

Concept

This program extracts and prints the last two digits of a number repeatedly using the modulo operator (% 100). After printing, it removes the last two digits using integer division (// 100). The process continues until the number becomes 0.

For 1234:

First iteration → 34
Second iteration → 12
no%100) #prints 34 by 1234/100 = 34 remainder from 12.34
no//100 #prints 12 by 1234//100 = 12 quotient, 34 is rem, avoids it

Algorithm

Start.
Assign no = 1234.
Check whether no > 0.
If true:

Print no % 100.
Update no = no // 100.
1. Repeat Step 3 until no = 0.
2. Stop.

Flowchart

 ┌───────┐
 │ Start │
 └───┬───┘
     │
     ▼
 ┌──────────┐
 │ no=1234  │
 └────┬─────┘
      │
      ▼
 ┌──────────┐
 │ no > 0   │───────
 └───┬──────┘      │
    Yes            No
     │             │
     ▼             ▼
┌────────────┐  ┌──────┐
│Print no%100│  │ Stop │
└─────┬──────┘  └──────┘
      │
      ▼
┌───────────┐
│no=no//100 │
└─────┬─────┘
      │
      └──────────► Back to Condition

Program

no = 1234

while no > 0:
    print(no % 100,end=" ")
    no = no // 100

🔄 Execution Table

Iteration [3, 4, 5, 6, 7]	Loop Condition (no > 0)	Execution Step	Operation	Result / Output
Start	Initial Value	Set starting number	no = 1234	no is 1234
Loop 1	1234 > 0 (True)	1. Print statement	1234 % 100	Prints 34 (Last 2 digits)
		2. Floor division	1234 // 100	no becomes 12 (removes last 2 digits)
Loop 2	12 > 0 (True)	1. Print statement	12 % 100	Prints 12 (Remaining digits)
		2. Floor division	12 // 100	no becomes 0
End	0 > 0 (False)	Loop terminates	Exit loop	Program finishes successfully

Trace Table

Iteration	no (Before)	no % 100	Output	no = no // 100
1	1234	34	34	12
2	12	12	12	0

Output

Task-3 : Sum of task 1 (34 23 12)

Concept

This program extracts overlapping two-digit numbers from 1234 using the modulo operator (% 100) and adds them. After each extraction, it removes only the last digit using integer division (// 10).

For 1234:

First iteration → 34
Second iteration → 23
Third iteration → 12

Sum = 34 + 23 + 12 = 69

no % 100 extracts the last two digits.
no // 10 removes only the last digit.
sum = sum + (no % 100) adds each extracted value to the total.

Algorithm

Start.
Assign no = 1234 and sum = 0.
Check whether no >= 10.
If true:

Add no % 100 to sum.
Update no = no // 10.
1. Repeat Step 3 until no < 10.
2. Print sum.
3. Stop.

Flowchart

 ┌───────┐
 │ Start │
 └───┬───┘
     │
     ▼
 ┌────────────────┐
 │ no=1234,sum=0  │
 └───────┬────────┘
         │
         ▼
 ┌──────────┐
 │ no >= 10 │───────
 └───┬──────┘      │
    Yes            No
     │             │
     ▼             ▼
┌────────────────┐ ┌──────────┐
│sum=sum+no%100  │ │Print sum │
└───────┬────────┘ └────┬─────┘
        │               │
        ▼               ▼
 ┌───────────┐       ┌──────┐
 │no=no//10  │       │ Stop │
 └─────┬─────┘       └──────┘
       │
       └──────────► Back to Condition

Program

no = 1234
sum = 0

while no >= 10:
    sum = sum + (no % 100)
    no = no // 10

print(sum)

🔄 Execution Table

Iteration	Loop Condition (no >= 10)	Operation	Calculation	Sum
Start	Initial Value	sum = 0	-	0
Loop 1	1234 >= 10 (True)	sum = sum + (1234 % 100)	0 + 34	34
		no = 1234 // 10	no = 123
Loop 2	123 >= 10 (True)	sum = sum + (123 % 100)	34 + 23	57
		no = 123 // 10	no = 12
Loop 3	12 >= 10 (True)	sum = sum + (12 % 100)	57 + 12	69
		no = 12 // 10	no = 1
End	1 >= 10 (False)	Loop terminates	Exit loop	69

Trace Table

Iteration	no (Before)	no % 100	Sum After Addition	no = no // 10
1	1234	34	34	123
2	123	23	57	12
3	12	12	69	1

Output

Task-4 : Sum of task 2 (34 12)

Concept

This program extracts and adds the last two digits of a number repeatedly using the modulo operator (% 100). After each extraction, it removes the last two digits using integer division (// 100).

For 1234:

First iteration → 34
Second iteration → 12

Sum = 34 + 12 = 46

no % 100 extracts the last two digits.
no // 100 removes the last two digits.
sum = sum + (no % 100) adds each extracted value to the total.

Algorithm

Start.
Assign no = 1234 and sum = 0.
Check whether no > 0.
If true:

Add no % 100 to sum.
Update no = no // 100.
1. Repeat Step 3 until no = 0.
2. Print sum.
3. Stop.

Flowchart

 ┌───────┐
 │ Start │
 └───┬───┘
     │
     ▼
 ┌────────────────┐
 │ no=1234,sum=0  │
 └───────┬────────┘
         │
         ▼
 ┌──────────┐
 │ no > 0   │───────
 └───┬──────┘      │
    Yes            No
     │             │
     ▼             ▼
┌────────────────┐ ┌──────────┐
│sum=sum+no%100  │ │Print sum │
└───────┬────────┘ └────┬─────┘
        │               │
        ▼               ▼
 ┌───────────┐       ┌──────┐
 │no=no//100 │       │ Stop │
 └─────┬─────┘       └──────┘
       │
       └──────────► Back to Condition

Program

no = 1234
sum = 0

while no > 0:
    sum = sum + (no % 100)
    no = no // 100

print(sum)

🔄 Execution Table

Iteration	Loop Condition (no > 0)	Operation	Calculation	Sum
Start	Initial Value	sum = 0	-	0
Loop 1	1234 > 0 (True)	sum = sum + (1234 % 100)	0 + 34	34
		no = 1234 // 100	no = 12
Loop 2	12 > 0 (True)	sum = sum + (12 % 100)	34 + 12	46
		no = 12 // 100	no = 0
End	0 > 0 (False)	Loop terminates	Exit loop	46

Trace Table

Iteration	no (Before)	no % 100	Sum After Addition	no = no // 100
1	1234	34	34	12
2	12	12	46	0

Output

Task-5 : Product of task 1 (34 23 12)

Concept

This program extracts overlapping two-digit numbers from 1234 using the modulo operator (% 100) and multiplies them. After each extraction, it removes only the last digit using integer division (// 10).

For 1234:

First iteration → 34
Second iteration → 23
Third iteration → 12

Product = 34 × 23 × 12 = 9384

no % 100 extracts the last two digits.
no // 10 removes only the last digit.
product = product * (no % 100) multiplies each extracted value.

Algorithm

Start.
Assign no = 1234 and product = 1.
Check whether no >= 10.
If true:

Multiply product with no % 100.
Update no = no // 10.
1. Repeat Step 3 until no < 10.
2. Print product.
3. Stop.

Flowchart

 ┌───────┐
 │ Start │
 └───┬───┘
     │
     ▼
 ┌────────────────────┐
 │ no=1234, product=1 │
 └────────┬───────────┘
          │
          ▼
 ┌──────────┐
 │ no >= 10 │───────
 └───┬──────┘      │
    Yes            No
     │             │
     ▼             ▼
┌────────────────────┐ ┌────────────┐
│product=product*%100│ │Print product│
└───────┬────────────┘ └────┬───────┘
        │                   │
        ▼                   ▼
 ┌───────────┐           ┌──────┐
 │no=no//10  │           │ Stop │
 └─────┬─────┘           └──────┘
       │
       └──────────► Back to Condition

Program

no = 1234
product = 1

while no >= 10:
    product = product * (no % 100)
    no = no // 10

print(product)

🔄 Execution Table

Iteration	Loop Condition (no >= 10)	Operation	Calculation	Product
Start	Initial Value	product = 1	-	1
Loop 1	1234 >= 10 (True)	product = product × (1234 % 100)	1 × 34	34
		no = 1234 // 10	no = 123
Loop 2	123 >= 10 (True)	product = 34 × (123 % 100)	34 × 23	782
		no = 123 // 10	no = 12
Loop 3	12 >= 10 (True)	product = 782 × (12 % 100)	782 × 12	9384
		no = 12 // 10	no = 1
End	1 >= 10 (False)	Loop terminates	Exit loop	9384

Trace Table

Iteration	no (Before)	no % 100	Product After Multiplication	no = no // 10
1	1234	34	34	123
2	123	23	782	12
3	12	12	9384	1

Output

Task-6 : Product of task 2 (34 12)

Concept

This program extracts the last two digits of a number repeatedly using the modulo operator (% 100) and multiplies them. After each extraction, it removes the last two digits using integer division (// 100).

For 1234:

First iteration → 34
Second iteration → 12

Product = 34 × 12 = 408

no % 100 extracts the last two digits.
no // 100 removes the last two digits.
product = product * (no % 100) multiplies each extracted value.

Algorithm

Start.
Assign no = 1234 and product = 1.
Check whether no > 0.
If true:

Multiply product with no % 100.
Update no = no // 100.
1. Repeat Step 3 until no = 0.
2. Print product.
3. Stop.

Flowchart

 ┌───────┐
 │ Start │
 └───┬───┘
     │
     ▼
 ┌────────────────────┐
 │ no=1234,product=1  │
 └────────┬───────────┘
          │
          ▼
 ┌──────────┐
 │ no > 0   │───────
 └───┬──────┘      │
    Yes            No
     │             │
     ▼             ▼
┌────────────────────┐ ┌────────────┐
│product=product*%100│ │Print product│
└───────┬────────────┘ └────┬───────┘
        │                   │
        ▼                   ▼
 ┌───────────┐           ┌──────┐
 │no=no//100 │           │ Stop │
 └─────┬─────┘           └──────┘
       │
       └──────────► Back to Condition

Program

no = 1234
product = 1

while no > 0:
    product = product * (no % 100)
    no = no // 100

print(product)

🔄 Execution Table

Iteration	Loop Condition (no > 0)	Operation	Calculation	Product
Start	Initial Value	product = 1	-	1
Loop 1	1234 > 0 (True)	product = 1 × (1234 % 100)	1 × 34	34
		no = 1234 // 100	no = 12
Loop 2	12 > 0 (True)	product = 34 × (12 % 100)	34 × 12	408
		no = 12 // 100	no = 0
End	0 > 0 (False)	Loop terminates	Exit loop	408

Trace Table

Iteration	no (Before)	no % 100	Product After Multiplication	no = no // 100
1	1234	34	34	12
2	12	12	408	0

Output

Task-7 : 123456 → Print 456 123

Concept

This program splits a 6-digit number into two parts using:

% 1000 → gives last 3 digits
// 1000 → gives first 3 digits

It prints both values in a loop style similar to the previous tasks.

For 123456:

First iteration → 456
Second iteration → 123

Algorithm

Start.
Assign no = 123456.
Check whether no > 0.
If true:

Print no % 1000.
Update no = no // 1000.
1. Repeat until no = 0.
2. Stop.

Flowchart

 ┌───────┐
 │ Start │
 └───┬───┘
     │
     ▼
 ┌──────────────┐
 │ no = 123456  │
 └────┬─────────┘
      │
      ▼
 ┌──────────┐
 │ no > 0   │───────
 └───┬──────┘      │
    Yes            No
     │             │
     ▼             ▼
┌────────────────┐ ┌──────┐
│Print no % 1000 │ │ Stop │
└─────┬──────────┘ └──────┘
      │
      ▼
┌──────────────┐
│ no = no//1000│
└─────┬────────┘
      │
      └──────────► Back to Condition

Program

no = 123456

while no > 0:
    print(no % 1000, end=" ")
    no = no // 1000

🔄 Execution Table

Iteration	no (Before)	no % 1000	Output	no = no // 1000
1	123456	456	456	123
2	123	123	123	0

Trace Table

Iteration	no (Before)	no % 1000	Output
1	123456	456	456
2	123	123	123

Output

📊 Number Manipulation Tasks

Task No	Input Number	Operation	Concept Used	Method	Output
1	1234	Print 34 23 12	Overlapping digit extraction	`% 100` + `// 10` in while loop	34 23 12
2	1234	Print 34 12	Non-overlapping digit extraction	`% 100` + `// 100` in while loop	34 12
3	1234	Sum of Task 1 values	Accumulation (Sum)	`sum = sum + value`	69
4	1234	Sum of Task 2 values	Accumulation (Sum)	`sum = sum + value`	46
5	1234	Product of Task 1 values	Accumulation (Product)	`product = product * value`	9384
6	1234	Product of Task 2 values	Accumulation (Product)	`product = product * value`	408
7	123456	Print 456 123	Number splitting	`% 1000` + `// 1000`	456 123

📌 Summary

% → extracts last digits
// → removes last digits
while loop → repeated digit processing
Overlapping extraction → // 10
Non-overlapping extraction → // 100 or // 1000
Sum logic → sum = sum + value
Product logic → product = product * value
Number splitting → large number separation
%100 --> gives last two digits
//100 --> removes last two digits
Additive Identity 0
Multiplicative identity 1
Floor division operator (//) calculates the integer quotient by rounding down to the nearest whole number
Modulo operator (%) calculates the remainder left over from that division.

Overall Learning Outcome

From these programs, we learn:

✔ How to extract digits without strings
✔ How loops control number processing
✔ How arithmetic operators manipulate data
✔ How patterns are formed from numbers
✔ Difference between sum and product accumulation
✔ Real-world use of digit splitting logic

Hands-On Conceptual Reference

Bhagyashree — Thu, 11 Jun 2026 15:28:50 +0000

EXAMPLE

 # Context Manager ensures safe execution and automatic file closure
with open("demo_log.txt", "w") as file:
    # List Comprehension generates an optimized collection
    squares = [x**2 for x in range(1, 6)]
    file.write(f"Processed Squares: {squares}")

This code does not print anything to your console but it creates a text file named demo_log.txt in the same directory as your script.

Inside demo_log.txt

If you open the newly created file, it will contain exactly this text:

Processed Squares: [1, 4, 9, 16, 25]

Visualizing the Data Generation

The code dynamically calculates and saves the mathematical squares of the numbers 1 through 5 (1², 2², 3², 4², 5²):

A practical, real-world example used to explain the theoretical idea.

Python combines memory efficiency, safe resource handling, and concise syntax to process and store data. It automatically writes the squares of numbers 1 through 5 into a text file while ensuring the file closes safely after execution. References:

https://zenodo.org

Context Manager (The with statement)

What it does: The syntax with open("demo_log.txt", "w") as file: opens the file for writing.
Why it’s used: It guarantees safe execution. When the indented block of code finishes running—or if an error occurs while writing—Python automatically and immediately closes the file. This prevents memory leaks and file corruption, which can happen if a file is left open accidentally. References:
https://apxml.com
https://www.linkedin.com
https://realpython.com
https://intellipaat.com

List Comprehension

What it does: The line squares = [x**2 for x in range(1, 6)] generates a list of numbers.
How it works: It loops through the numbers 1 through 5, squares each number (using the exponent operator **), and immediately packs the results into a new list. In mathematics, this represents calculating x² for all x ∈ {1, 2, 3, 4, 5}
Why it’s used: It is a highly optimized, readable, and concise way to create lists in Python without needing multi-line for loops.

Collections are iterable.
Expressions produces the output within the program.
Conditions are optional.

File Writing

What it does: file.write(f"Processed Squares: {squares}") writes the resulting list directly into "demo_log.txt".

How it works: The f before the string denotes an f-string (formatted string literal). It allows you to embed the squares variable directly inside the text. The file will ultimately contain the text: Processed Squares: [1, 4, 9, 16, 25].

Python Concepts Takeaways

1. Resource Management & RAII (Context Managers)

In programming, resources like files, network sockets, and database connections are limited. If you open a file, the operating system locks it. But if you forget to close it, there will be a "memory leak," which can crash the system. [1, 2]

Earlier: Developers used try...finally blocks to manually force files to close. It required four to five lines of boilerplate code-(sections of code that you must write in multiple places with little or no modification). [3]
The Solution: Python uses Context Managers via the with statement. This implements a design pattern called Resource Acquisition Is Initialization (RAII). [4]
How it works under the hood: The object returned by open() has two hidden magic methods: __enter__() and __exit__().
The __enter__ method sets up the file
The __exit__ method guarantees that the file closes automatically as soon as the code block finishes, even if the program crashes.

2. Declarative Programming (List Comprehensions)

Traditional loops are imperative—(write step-by-step instructions) on how to build a list (create empty list, start loop, append item). List comprehension leans toward declarative programming—(you describe what you want the final list to look like). [5, 6, 7, 8]

The Benefit: It is not just syntactic sugar-(a feature in a programming language that makes the code easier to read or write, without adding any new functionality) to save space. Python optimizes list comprehensions at the C-level. They run significantly faster than a standard .append() loop because Python doesn't have to repeatedly look up the append attribute in memory for every single iteration. [9]

3. I/O Operations & Stream Buffering (File Writing)

When you call file.write(), your computer does not immediately spin your hard drive or write to your Solid-state drive(SSD).

How it works under the hood-(behind the scenes): Writing to physical storage is incredibly slow compared to CPU speeds. Python uses buffered I/O. It holds the text string in RAM (a buffer) until it accumulates enough data to justify a write operation. [10, 11]
The Connection: The Context Manager plays a vital role here. When the with block closes, it triggers a flush command, forcing any remaining data in the RAM buffer to be safely committed to the demo_log.txt file on your disk. [12]

4. String Interpolation (F-Strings)

String interpolation means replacing placeholders-(a temporary symbol, character, or piece of text used to reserve a specific spot until the actual data or variable value replaces it)or variables inside a text string directly with their actual values.
Instead of cutting a sentence apart to glue a variable onto it, you write the sentence naturally and inject the variable right into the middle of the text.
Historically, combining text and variables in Python required messy syntax like "Processed Squares: " + str(squares) or using .format().

How it works under the hood: Introduced in Python 3.6, f-strings (formatted string literals-Python feature that lets you embed variables or expressions directly inside a string layout) evaluate expressions at runtime. The f prefix tells Python to parse-(to analyze a string of text or data by breaking it down into smaller, understandable pieces that a computer system can process) the string and look for {} braces. [13, 14]
The Benefit: Instead of converting the list to a string manually, Python implicitly calls the list's internal string representation method (__str__) and directly merges it into the text layout. This makes f-strings the fastest string formatting method available in Python.

References:
[1] https://www.edureka.co
[2] https://medium.com
[3] https://blog.logrocket.com
[4] https://realpython.com
[5] https://blog.nashtechglobal.com
[6] https://github.com
[7] https://python.plainenglish.io
[8] https://www.scribd.com
[9] https://www.scribd.com
[10] https://www.scribd.com
[11] https://www.cliffsnotes.com
[12] https://www.pythonmorsels.com
[13] https://www.scribd.com
[14] https://mtgcoach.online

Basics of Python

Bhagyashree — Wed, 10 Jun 2026 17:14:55 +0000

1. Variables

Variables store data.

name = "Arun"
age = 20
height = 5.8

Here:

name stores text (string)
age stores a whole number (integer)
height stores a decimal number (float)

print(name)
print(age)

Output:

Arun
20

2. Data Types

Common Python data types:

name = "Python"      # string
age = 25             # integer
price = 99.99        # float
is_active = True     # boolean

Check a type:

print(type(age))

3. Input and Output

Getting input from the user:

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

Example:

Enter your name: Ravi
Hello Ravi

4. Operators

Arithmetic

a = 10
b = 3

print(a + b)  # addition
print(a - b)  # subtraction
print(a * b)  # multiplication
print(a / b)  # division
print(a % b)  # remainder

Comparison

print(a > b)
print(a < b)
print(a == b)

5. Conditional Statements (if)

Make decisions in code.

age = 18

if age >= 18:
    print("Adult")
else:
    print("Minor")

Multiple conditions:

marks = 75

if marks >= 90:
    print("A")
elif marks >= 70:
    print("B")
else:
    print("C")

6. Loops

For Loop

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

Output:

While Loop

count = 1

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

7. Lists

Store multiple values.

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

print(fruits[0])

Add an item:

fruits.append("mango")

Loop through a list:

for fruit in fruits:
    print(fruit)

8. Functions

Functions let you reuse code.

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

greet("Kumar")

Return values:

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

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

9. Dictionariesv

Store data as key-value pairs.

student = {
    "name": "Arun",
    "age": 20,
    "city": "Chennai"
}

print(student["name"])

10. Importing Modules

Use built-in Python libraries.

import math

print(math.sqrt(25))

Output:

5.0

11. Error Handling

Prevent programs from crashing.

try:
    num = int(input("Enter number: "))
    print(num)
except ValueError:
    print("Please enter a valid number")

12. A Complete Beginner Program

name = input("Enter your name: ")
age = int(input("Enter your age: "))

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

Blog

Bhagyashree — Tue, 09 Jun 2026 14:49:24 +0000

A Blog or a weblog is a website used for updating consistently, similar to an online journal , which is created to share the journey of personal opinions, learning, doing new things, expertise in a particular field or a skill, and updating the happenings in our surroundings and bringing up information into the digital world as insights of enlightenment.

Why Start a Blog?

Share your story. A blog allows you to have a voice and be heard. You can share your story with the entire world if you so choose. One of the most common ways blogs are used is as a diary where the blogger writes about their daily experiences so that friends, family, and others can all be a part of their lives.
Make money from home. Blogging can be quite lucrative if done
correctly. The top bloggers in the world obviously earn quite a bit, but even a part-time blogger can expect to make a nice profit if things are done correctly. The best part about it is that blogging is a form of passive income, since you can spend just a few hours a week writing a piece of content and then continue to profit from it long after the writing is finished. I go into much more detail on how
Recognition for yourself or your business. No, you probably won’t have paparazzi following you around because of your latest post. But a successful blog makes your idea into a reality, and can gain you a ton of recognition in your respective field. Many bloggers are known as experts just because of their blogs, and some have even gotten book and movie deals based on their blogs.
Find a community. Blogging at its heart is interactive. You write a post and people comment on it. This is a good way to connect with people who are interested in the same things as you are. Blogging allows you to teach these people based on your experience, and it allows you to learn from your readers as well.
https://www.theblogstarter.com/

Courtesy: Scalenut

In-short

Build an Audience: Connect with readers who share your passions or professional niche.
Establish Authority: Showcase your expertise and build trust with potential clients or employers.
Monetization: Generate income through affiliate marketing, sponsored posts, or ad placements. References: https://www.blogger.com/

Courtesy: https://www.chitkara.edu.in/blogs/the-significance-of-blogging-in-digital-marketing/