DEV Community: Mary Nyandia

While Loops: Repetition with Control in Python

Mary Nyandia — Thu, 04 Jun 2026 13:20:00 +0000

Basic While Loop
While loops run as long as a condition is true. This makes them flexible for tasks where the number of repetitions isn’t known in advance.

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

Break Statement
break lets you exit a loop early, even if the condition is still true. This is useful for stopping once a certain condition is met.

number = 0
while True:
    number += 1
    if number == 3:
        break

Continue Statement
continue skips the rest of the loop for the current iteration and moves to the next one. This is handy for filtering data during iteration.

n = 0
while n < 5:
    n += 1
    if n % 2 == 0:
        continue
    print("Odd number:", n)

My Take
While loops provide flexibility by running until conditions change. Combined with break and continue, they give fine‑grained control over repetition.

File Handling in Python: Reading, Writing, and Managing Data

Mary Nyandia — Thu, 04 Jun 2026 13:10:13 +0000

Writing Files
Using open() with "w" mode, you can create or overwrite files. The with statement ensures files are closed properly.

filename = "sample.txt"

with open(filename, "w", encoding="utf-8") as file:
    file.write("Hello file handling!\n")
    file.write("This is a second line.\n")
print("Wrote to", filename)

Reading Files
open() with "r" mode lets you read files. read() loads the entire content, while iterating reads line by line.

with open(filename, "r", encoding="utf-8") as file:
    content = file.read()
print("File content:")
print(content)

Line‑by‑Line Reading
Reading files line by line is efficient for large files, as it avoids loading everything into memory at once.

with open(filename, "r", encoding="utf-8") as file:
    for line in file:
        print("Line:", line.strip())

My take
File handling allows Python to interact with the outside world. You can:

Write data to files for storage.
Read files to process information.
Handle files line by line for efficiency. This skill is essential for building applications that log activity, store user data, or process text files.

Smart Decisions with Python Conditionals: If, Elif, Else

Mary Nyandia — Thu, 04 Jun 2026 12:03:33 +0000

Basic If‑Else
Conditionals let your program make decisions. Using if, elif, and else, you can handle multiple scenarios, ensuring your program responds appropriately to different inputs.

def check_number(number):
    if number > 0:
        print(number, "is positive")
    elif number < 0:
        print(number, "is negative")
    else:
        print(number, "is zero")

Nested Conditions
You can layer conditionals to handle complex logic. This is useful for grading systems, validations, or multi‑step decision processes.

score = 85
if score >= 90:
    print("Grade: A")
elif score >= 80:
    print("Grade: B")
else:
    print("Grade: C or below")

Importance of Conditionals
Conditionals are the backbone of interactive programs. They allow your code to adapt to situations, validate inputs, and control flow.

My Take
Conditionals make programs smart and responsive. They allow you to handle multiple scenarios, validate inputs, and control program flow effectively.

Iteration Everywhere: Navigating Lists, Dictionaries, and Strings

Mary Nyandia — Thu, 04 Jun 2026 11:45:39 +0000

Iterating Over Lists
Iteration lets you process each item in a list, making it easy to handle collections of data.

values = [10, 20, 30]
for value in values:
    print("Value:", value)

Iterating With Index
Using enumerate(), you can access both the index and the value, which is useful for tracking positions.

for index, value in enumerate(values):
    print(index, value)

Iterating Over Dictionaries
Dictionaries can be iterated to access both keys and values, making them ideal for structured data.

info = {"a": 1, "b": 2}
for key, value in info.items():
    print(key, value)

Iterating Over Strings
Strings are sequences too, so you can loop through each character for tasks like text analysis.

for char in "hello":
    print("Character:", char)

My take
Iteration is fundamental for processing collections. Whether lists, dictionaries, or strings, loops let you handle data systematically and efficiently.

While Loops: Repetition with Control in Python

Mary Nyandia — Thu, 04 Jun 2026 11:38:43 +0000

Basic While Loop
While loops run as long as a condition is true. This makes them flexible for tasks where the number of repetitions isn’t known in advance.

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

Break Statement
break lets you exit a loop early, even if the condition is still true. This is useful for stopping once a certain condition is met.

number = 0
while True:
    number += 1
    if number == 3:
        break

Continue Statement
continue skips the rest of the loop for the current iteration and moves to the next one. This is handy for filtering data during iteration.

n = 0
while n < 5:
    n += 1
    if n % 2 == 0:
        continue
    print("Odd number:", n)

My take
While loops provide flexibility by running until conditions change. Combined with break and continue, they give fine‑grained control over repetition.

Smart Decisions with Python Conditionals: If, Elif, Else

Mary Nyandia — Thu, 04 Jun 2026 11:37:10 +0000

Basic If‑Else
Conditionals let your program make decisions. Using if, elif, and else, you can handle multiple scenarios, ensuring your program responds appropriately to different inputs.

Nested Conditions
You can layer conditionals to handle complex logic. This is useful for grading systems, validations, or multi‑step decision processes.

Importance of Conditionals
Conditionals are the backbone of interactive programs. They allow your code to adapt to situations, validate inputs, and control flow.

From Blueprints to Reality: Python Classes and Objects

Mary Nyandia — Thu, 04 Jun 2026 11:29:19 +0000

I explored object‑oriented programming (OOP) in Python — a way to structure code using classes (blueprints) and objects (instances of those blueprints). OOP makes programs more organized, reusable, and closer to how we think about real‑world entities.

1.Basic Class Definition
Classes define attributes and methods. Objects are created from classes and can use those methods.

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

    def describe(self):
        return f"{self.name} is a {self.species}"

dog = Animal("Buddy", "Dog")
cat = Animal("Whiskers", "Cat")
print(dog.describe())
print(cat.describe())

2.Class with Multiple Methods
Methods can check conditions, modify attributes, or return information.

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

    def is_honor_student(self):
        return self.gpa >= 3.5

    def promote(self):
        self.grade += 1
        return f"{self.name} is now in grade {self.grade}"

3.Class vs Instance Attributes
Class attributes are shared by all objects, while instance attributes are unique to each object.

class Car:
    wheels = 4  # Class attribute

    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

4.Inheritance
Inheritance lets child classes reuse and extend parent class functionality.

class Vehicle:
    def __init__(self, make, color):
        self.make = make
        self.color = color

class Motorcycle(Vehicle):
    def __init__(self, make, color, has_sidecar):
        super().__init__(make, color)
        self.has_sidecar = has_sidecar

5.Encapsulation
Private attributes (__balance) hide sensitive data, and getter methods provide controlled access.

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

    def get_balance(self):
        return self.__balance

6.Special Methods (Dunder Methods)
Special methods like str, eq, and lt customize how objects behave with built‑in functions.

class Person:
    def __str__(self):
        return f"{self.name}, {self.age} years old"

7.Multiple Objects in a List
You can store multiple objects in lists and iterate over them.

books = [Book("1984", "George Orwell", 328),
         Book("The Great Gatsby", "F. Scott Fitzgerald", 180)]
for book in books:
    print(book.show_info())

8.Object Composition
Composition means one object contains another, building complex structures.

class Employee:
    def __init__(self, name, job_title, address):
        self.address = address

9.Static and Class Methods
Static methods don’t depend on object data, while class methods can access class‑level attributes.

class MathsHelper:
    @staticmethod
    def add(a, b): return a + b
    @classmethod
    def create_circle(cls, radius): ...

10.Polymorphism
Polymorphism lets different classes implement the same method (area) in their own way.

class Shape: 
    def area(self): raise NotImplementedError

🎯 My Take
Classes and objects are the foundation of OOP in Python. They help you:

Organize code into reusable blueprints.
Model real‑world entities with attributes and methods.
Use inheritance, encapsulation, and polymorphism for powerful designs.

Error Handling Made Easy: Python Exceptions Explained

Mary Nyandia — Thu, 04 Jun 2026 09:39:07 +0000

Today I explored exceptions — Python’s way of handling errors gracefully. Instead of crashing when something goes wrong, exceptions let you catch problems, respond to them, and keep your program running smoothly

1.Handling Conversion Errors
Here, Python raises a ValueError because "abc" cannot be converted into an integer. The except block catches the error and prints a helpful message instead of stopping the program.

try:
    value = int("abc")
    print("Converted value:", value)
except ValueError:
    print("ValueError: could not convert string to int")

2.Handling Index Errors
Accessing an index that doesn’t exist raises an IndexError. Catching it prevents your program from crashing.

try:
    numbers = [1, 2, 3]
    print(numbers[5])
except IndexError:
    print("IndexError: index out of range")

3.Using (finally) for Cleanup
The finally block runs no matter what , whether an error occurs or not. This is useful for cleanup tasks like closing files or releasing resources.

try:
    result = 10 / 2
except ZeroDivisionError:
    print("Cannot divide by zero")
else:
    print("Division result:", result)
finally:
    print("This always runs")

🎯 My Take
Exceptions make your programs more robust and user friendly. They let you:

Catch and handle errors gracefully.
Provide meaningful feedback instead of crashing.
Use finally to ensure important cleanup always happens.

Mastering exceptions is essential for building reliable applications that can handle unexpected situations.

File Handling

Mary Nyandia — Thu, 04 Jun 2026 09:20:37 +0000

Writing Files
Using open() with "w" mode, you can create or overwrite files. The with statement ensures files are closed properly.

filename = "sample.txt"

with open(filename, "w", encoding="utf-8") as file:
    file.write("Hello file handling!\n")
    file.write("This is a second line.\n")
print("Wrote to", filename)

Reading Files
open() with "r" mode lets you read files. read() loads the entire content, while iterating reads line by line.

with open(filename, "r", encoding="utf-8") as file:
    content = file.read()
print("File content:")
print(content)

Line‑by‑Line Reading
Reading files line by line is efficient for large files, as it avoids loading everything into memory at once.

with open(filename, "r", encoding="utf-8") as file:
    for line in file:
        print("Line:", line.strip())

🎯 My Take
File handling allows Python to interact with the outside world. You can:

Write data to files for storage.
Read files to process information.
Handle files line by line for efficiency.

This skill is essential for building applications that log activity, store user data, or process text files.

Iteration

Mary Nyandia — Thu, 04 Jun 2026 09:09:44 +0000

Iterating Over Lists
Iteration lets you process each item in a list, making it easy to handle collections of data.

Iterating With Index
Using enumerate(), you can access both the index and the value, which is useful for tracking positions.

Iterating Over Dictionaries
Dictionaries can be iterated to access both keys and values, making them ideal for structured data.

Iterating Over Strings
Strings are sequences too, so you can loop through each character for tasks like text analysis.

While Loops

Mary Nyandia — Thu, 04 Jun 2026 09:04:45 +0000

Basic While Loop
While loops run as long as a condition is true. This makes them flexible for tasks where the number of repetitions isn’t known in advance.

Break Statement
break lets you exit a loop early, even if the condition is still true. This is useful for stopping once a certain condition is met.

Continue Statement
continue skips the rest of the loop for the current iteration and moves to the next one. This is handy for filtering data during iteration.

Conditionals

Mary Nyandia — Thu, 04 Jun 2026 09:02:17 +0000

Basic If‑Else
Conditionals let your program make decisions. Using if, elif, and else, you can handle multiple scenarios, ensuring your program responds appropriately to different inputs.

Nested Conditions
You can layer conditionals to handle complex logic. This is useful for grading systems, validations, or multi‑step decision processes.

Importance of Conditionals
Conditionals are the backbone of interactive programs. They allow your code to adapt to situations, validate inputs, and control flow.