DEV Community: Mary Nyandia

Getting Started with Data Projects: My Honest Learning Journey

Mary Nyandia — Tue, 07 Jul 2026 22:07:54 +0000

When I first dipped my toes into the world of data projects, I thought it would be all about numbers, charts, and maybe a bit of SQL. But what I’ve discovered is that data projects are more like stories, they have beginnings, mistakes, lessons, and truths that unfold as you go.

Starting Out: The Excitement and the Reality
I began with the basics: “Getting started with data projects.” At first, it felt exciting, like opening a new chapter in tech. But almost immediately, I ran into the reality check: there are common beginner mistakes that everyone makes. I realized I was rushing into analysis without really understanding the dataset. It’s like trying to cook without knowing your ingredients. That lesson humbled me.

Meeting the Datasets
Then came the part about Excel datasets and database datasets. I had always thought Excel was enough, after all, it’s familiar, right? But learning about database datasets opened my eyes. Databases are like vast libraries compared to Excel’s notebooks. They’re structured, scalable, and built for serious projects. That moment felt like discovering a bigger playground.

The Golden Rule: Protect the Raw Data
One of the most powerful lessons was about maintaining original data. I used to think it was fine to tweak data directly, but I learned that raw data is sacred. Once you lose it, you lose the truth. Keeping it intact means you can always go back, validate, and trust your work. It’s like keeping a diary, you don’t erase the original entries, you build on them.

Understanding Truths in Data
This part hit me differently. Data isn’t just numbers; it represents truths about people, processes, and decisions. Handling it responsibly means respecting those truths. It made me realize that being a data analyst isn’t just technical, it’s ethical.

Importing, Exporting, and Connections
Later, I explored data governance, source data, flat files, and connections. At first, these sounded intimidating, but they’re really about managing the flow of information. I even learned how to create datasets for others, which felt empowering. It’s like cooking a meal not just for yourself, but for a whole team.

Reflections: More Than Just Skills
Looking back, this journey wasn’t just about learning tools. It was about discipline, patience, and curiosity. I made mistakes, but each one taught me something valuable. And while I’m still learning, I feel more confident about tackling bigger projects in the future.

✨ Takeaway:
Data projects are not just technical exercises, they’re journeys of discovery. If you’re starting out, embrace the mistakes, protect your raw data, and remember that every dataset tells a story.

My Journey Into Data Analysis: From Basics to SQL

Mary Nyandia — Sat, 04 Jul 2026 22:48:10 +0000

Over the past few weeks, I’ve been diving into the fundamentals of data analysis. It’s been an eye opening experience, and I’d like to share some of the key lessons I’ve learned so far.

1. Getting Started with Data Analysis
The first step was understanding what data analysis really means and what a data analyst does. I discovered that being an analyst isn’t just about crunching numbers it’s about curiosity, problem solving, and asking the right questions.

I also learned about the different organizational roles in data and how analysts fit into the bigger picture. This helped me see that data analysis is not a one size fits all career; there are multiple paths depending on your interests and strengths.

2. Fundamentals of Data Understanding
Next, I explored how to identify data and understand different data fields and types. One of the most important lessons was dealing with missing data because in the real world, datasets are rarely perfect.

This section also introduced me to SQL basics. Learning syntax and writing simple SQL statements gave me a taste of how powerful structured queries can be. I even tackled a small challenge on reading SQL, which boosted my confidence.

3. Key Elements When Starting Data Analysis
Finally, I got into the practical side of things: interpreting existing data, finding sources, and cleaning datasets. Cleaning data may sound boring, but it’s actually one of the most critical steps garbage in, garbage out!

I also learned about joins and how they help connect different tables to create meaningful insights. Working with joins and validation showed me how analysts ensure accuracy in their results.

Reflections
This journey has taught me that data analysis is more than just technical skills, it’s about mindset. While I’m still at the beginning, I’m excited to keep building my skills in SQL, data cleaning, and workflow understanding.

I may not have all the answers yet, but I’m willing to take risks, learn, and grow. And who knows? Maybe this path will lead me deeper into web development and data projects in the future.

✨ Takeaway:
If you’re starting out in tech, don’t be afraid to explore different areas. You might discover that data analysis is not just about numbers, it’s about uncovering stories hidden in the data.

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.