DEV Community: Moh

Learning Reflection Pig Latin Translator

Moh — Tue, 22 Apr 2025 16:56:27 +0000

Building a Pig Latin Translator in Python

Introduction

Today, I decided to apply my Python knowledge to tackle the first project in Impractical Python Projects: building a Pig Latin translator. This challenge was a fun way to practice string manipulation, loops, and conditional logic. Below, I’ve shared my solution and compared it to the book’s version, reflecting on the differences and lessons learned.

My Solution

Here's the code I wrote for the Pig Latin translator:

vowels = ["a", "e", "i", "o", "u"]

while True:
    word = input("Please type a word to translate to pig latin (or type 'q' to exit):\n").lower()

    if word == "q":
        print("Goodbye")
        break

    char_list = list(word)

    if char_list[0] in vowels:
        print(f"{word}yay")
    else:
        f_letter = char_list.pop(0)
        char_list.append(f_letter)
        print(f"{''.join(char_list)}ay")

How It Works:

I defined a list of vowels and used it to determine if the first letter was a vowel.
If the word started with a vowel, I added "yay" to the end.
If it started with a consonant, I moved the first letter to the end and added "ay".
The program allows users to input multiple words, exiting with 'q'.

Book Solution

Here’s the solution provided in the book:

"""Turn a word into its Pig Latin equivalent."""
import sys

VOWELS = 'aeiouy'

while True:
    word = input("Type a word and get its Pig Latin translation: ")

    if word[0] in VOWELS:
        pig_Latin = word + 'way'
    else:
        pig_Latin = word[1:] + word[0] + 'ay'

    print()
    print("{}".format(pig_Latin), file=sys.stderr)

    try_again = input("\n\nTry again? (Press Enter else n to stop)\n")
    if try_again.lower() == "n":
        sys.exit()

How It Works:

Uses a string of vowels ('aeiouy') for simpler membership checks.
Uses slicing (word[1:], word[0]) for rearranging characters.
Adds "way" if the word starts with a vowel.
Uses the sys module to cleanly exit and print to stderr.

Reflection: Differences and Insights

1. Data Structure for Vowels

Mine: List (["a", "e", "i", "o", "u"]) – intuitive for me while practicing lists.
Book: String ('aeiouy') – more concise and efficient.
Takeaway: Strings work better for single-character membership checks.

2. Handling Translation Logic

Mine: Converted the word to a list to manipulate characters.
Book: Used slicing – more Pythonic and efficient.
Takeaway: Avoid unnecessary data structure changes when strings suffice.

3. Program Interaction

Mine: Exit via typing "q".
Book: Offers a retry prompt, exits cleanly with sys.exit().
Takeaway: Adding prompts enhances UX and polish.

Lessons Learned

Keep it simple: The book’s version is shorter and more elegant.
User experience matters: A retry prompt improves flow.
Explore new tools: Using modules like sys opens up new possibilities.

This project was a great way to practice problem-solving and reflect on different styles of coding. Going forward, I’ll aim for more concise and readable solutions.

Closing Thoughts

Tackling the Pig Latin translator was a rewarding hands-on exercise. Comparing my approach with the book’s gave me useful insights and highlighted areas where I can improve. I'm excited to continue working through more projects and leveling up my Python skills.

Thanks for reading, and let’s see what the tide brings tomorrow!

Join Me on My Journey

If you’d like to follow along, I’ll be sharing more about my learning process, projects, and insights here and on my GitHub repository. Feel free to connect — I’d love to hear about your coding journey too!

Python Progress: Lists, Logic, and Building Interactive Tools

Moh — Thu, 20 Feb 2025 07:30:27 +0000

Introduction

Learning Python is like peeling an onion—every layer reveals something new, exciting, and occasionally tear-inducing (hello, off-by-one errors). Over the past week, I’ve delved deeper into lists, slicing, the range() function, conditional logic with if statements, and the powerful zip() function. Alongside learning PEP 8 and using Ruff as a linter, I also started building interactive tools and tackling challenges from Impractical Python Projects.

These experiences have deepened my understanding of Python and emphasized the importance of writing clear, maintainable code.

Lists: Flexible and Fun (Most of the Time)

Lists continue to impress me with their versatility. Whether I’m appending items or removing them with pop(), I’m starting to see how lists play a central role in many of the tools I want to build.

Slicing and Range

I’ve also explored slicing, which makes accessing subsets of data intuitive—except when I forget that Python starts counting at zero. Combining slicing with range() has been a game changer for generating sequences and working with lists dynamically. It’s elegant, but the occasional off-by-one error keeps me on my toes.

List Comprehensions: Strange but Powerful

When I first encountered list comprehensions, they felt backward—why put the variable before the value? But after a bit of practice, I’ve realized their true power. For example, I can now condense a multi-line loop into a single line:

squares = [x**2 for x in range(1, 6)]

List comprehensions have started to feel like a Python superpower. They simplify tasks like filtering data or transforming lists, and I’m excited to see how I can use them in future projects.

Adding Logic with If Statements

Recently, I took my first steps into conditional logic with if statements, adding a new dimension to my programs. I practiced scenarios like checking if a list is empty, filtering data, and creating dynamic outputs.

For example, splitting a list into odd and even numbers is now as simple as:

even_numbers = [x for x in numbers if x % 2 == 0]
odd_numbers = [x for x in numbers if x % 2 != 0]

It’s empowering to see how these small decisions can lead to smarter, more interactive programs.

Exploring the Zip Function

The zip() function has been a revelation. This tool allows me to combine multiple lists into pairs or tuples, creating a more structured way to work with related data.

For instance, pairing grades with their numeric values felt effortless using zip:

numbers = [90, 85, 78]
grades = ['A', 'B', 'C']
summary = list(zip(numbers, grades))
print(summary)  # Output: [(90, 'A'), (85, 'B'), (78, 'C')]

This concise approach integrates neatly into real-world tasks like summaries or comparisons. It’s also a reminder of how Python’s built-in functions simplify everyday programming challenges.

Following PEP 8 with Ruff

PEP 8, Python’s style guide, lays out conventions for writing clean and consistent code. As I’ve started applying these standards, I’ve realized how they make code easier to read and collaborate on. From proper indentation to descriptive variable names, PEP 8 is a helpful blueprint for maintainable Python projects.

To enforce these guidelines, I’ve been using Ruff, a fast and lightweight linter. Ruff not only identifies style violations but also provides suggestions for improvement. For example, it’s helped me catch redundant imports, ensure consistent whitespace, and write cleaner list comprehensions.

Here’s a quick example of how Ruff keeps my code in check:

# Before Ruff's suggestions
numbers=[1,2,3]
print( [x*2 for x in numbers] )

# After applying Ruff's recommendations
numbers = [1, 2, 3]
print([x * 2 for x in numbers])

This process has not only improved the quality of my code but also taught me to appreciate the importance of clean formatting.

Building My First Interactive Tool

With my new skills, I decided to create a tool that ties everything together. The program generates a list of random numbers and lets users interact with it through several features:

Generate Random Numbers: Create a list of 10 numbers between 1 and 100.
Split into Odd and Even: Detect and separate odd and even numbers.
Convert to Grades: Map numbers to a letter grading scale (A-F).
Summarize Grades: Pair each number with its grade using the zip() function.

Here’s a snippet of the program in action:

Do you want to split into odd and even numbers? yes
This is a list of even numbers:
[42, 88, 60]
This is a list of odd numbers:
[15, 73, 97]

Do you want to convert the list to an A-F grading scale? yes
This is our list in a grading system:
['C', 'B', 'A', 'D', 'F']

Do you want a summary of all grades? yes
You scored 73, and your grade is C.
You scored 88, and your grade is B.
You scored 97, and your grade is A.

Creating this program taught me how to use loops, conditionals, and list comprehensions together. It also showed me where I can improve, like handling invalid user inputs and modularizing my code with functions.

The To-Do App Debate: Resolved

For days, I debated whether to start building a To-Do app as my first substantial project or wait until I’ve mastered more concepts like loops and functions. After creating this interactive tool, I realized that waiting for “perfect” knowledge would hold me back.

Instead, I’ve decided to tackle projects now and use them as opportunities to learn along the way. My next step is to dive into Impractical Python Projects and implement a real-world challenge. This will supplement my learning with practical problem-solving while also giving me the freedom to experiment.

Reflections

Balancing structured learning with practical exploration has been one of the most rewarding challenges of this journey. Implementing projects like the interactive tool and tools involving zip() reminds me that programming is best learned by doing.

If you’re learning Python, I highly recommend exploring PEP 8, trying out a linter like Ruff, and starting small projects to consolidate your knowledge. These small steps will greatly improve your coding skills and make your projects shine.

Thanks for reading, and let’s see what the tide brings tomorrow!

Join Me on My Journey

My Python Journey: From Zen to Lists

Moh — Sat, 18 Jan 2025 12:33:15 +0000

Welcome to my very first post! I’m excited to begin documenting my journey of learning to code, sharing projects, and growing along the way.

Why I Started This Journey

Hi, I’m a husband, a father of three, and a full-time professional working with data. My day-to-day involves a lot of qualitative and quantitative analysis, and I’ve decided to reignite my passion for coding to expand my skill set. Learning Python has been an exciting step forward in blending my professional expertise with new problem-solving techniques.

This blog is part of how I internalize the concepts I’m learning while sharing my journey with others who might also be exploring Python.

The Zen of Python: A Philosophy to Code By

One of the first things I encountered on this journey was the “Zen of Python,” a set of principles encapsulating Python’s design philosophy. Two lines in particular stood out to me:

“Simple is better than complex.”

“Readability counts.”

As someone who thrives on clarity and efficiency in data analysis, I find this approach to programming intuitive. Python encourages writing code that’s not just functional but also understandable for others and even your future self!

Learning the Basics: Variables, Arithmetic, and Lists

Starting with the basics was like revisiting an old friend from college. Assigning values to variables felt natural, and working with arithmetic operators reminded me how much power lies in simple expressions. But it wasn’t all smooth sailing — discovering that 0.1 + 0.2 != 0.3 (thanks to floating-point precision quirks) was a reminder that even simple concepts can have layers of complexity.

Experimenting with Text Manipulation

One of the most satisfying exercises so far has been working with text. I’ve played around with:

Converting names to uppercase, lowercase, and titlecase.
Cleaning up strings with strip() to remove unnecessary spaces.

These small manipulations might seem trivial, but they’ve shown me how powerful Python is for transforming messy input into polished output — something that has practical applications in data preprocessing and presentation.

The Quote Debate

A fun discovery was that Python doesn’t care whether I use single quotes (') or double quotes ("). They both work equally well for strings. For now, I’ve settled on single quotes because I don’t want to press the shift key (yes, a valid reason, I know!). However, I’ll be using triple quotes when working with embedded quotes. This is one of those stylistic choices that will probably evolve as I write more code.

What’s Next: Loops and Control Flow

While I’m enjoying lists and text manipulation, I can’t wait to learn about loops. Repeating tasks manually is fine for now, but learning how to automate these processes with for and while loops will be a game changer. Similarly, diving into control flow with if statements will add logic to my programs, making them smarter and more responsive.

Reflections on the Process

This journey is about more than learning Python. It’s about building a mindset of curiosity and problem-solving. Each concept I learn builds on the last, and every small milestone feels like progress. It’s been inspiring to see how Python’s simplicity and flexibility allow me to apply programming to both practical challenges and creative projects.

Final Thoughts

For anyone starting their own Python journey, the best advice I’ve found—and am trying to live by—is to start small and keep building. Whether it’s a basic script or a mini-project, every bit of progress adds up. I’m excited to keep learning, documenting, and sharing this journey.

Thanks for reading, and let’s see what the tide brings tomorrow!