My First Byte into AI/ML: A Week of Python & Git Mastery with GDG Open Cloud Fellowship

Author: Hammad Ali , Date: February 2, 2026 Reading Time: ~7 minutes

Introduction: From Python Newbie to AI Enthusiast

As I wrap up Week 1 of the GDG Open Cloud AI/ML Fellowship 2026, I’m struck by how much ground we’ve covered. What started as a daunting dive into Python’s depths has transformed into a foundational understanding of building robust, production-ready applications — the bedrock of any AI/ML journey. This week wasn’t just about writing code; it was about building a mindset for structured development, understanding the “why” behind every “how,” and realizing the power of community learning.

Photo by Rubaitul Azad on Unsplash

Task 1: The Python Basics — More Than Just “Hello, World!”

We kicked off with the absolute fundamentals. But even here, the fellowship pushed us beyond surface-level scripting. We tackled:

• Setting up a professional VS Code environment: Learning to use virtual environments (venv) was a game-changer for dependency management.
• Core Python Concepts: From if-else statements and loops to string manipulation and basic data types, we solidified our understanding through practical problems like a number guessing game and factorial calculations.
• The AI/ML Landscape: A crucial part was summarizing the distinctions between AI, Machine Learning, Deep Learning, and Data Science. This provided a high-level map for the journey ahead.

My Key Takeaway: The importance of a clean setup cannot be overstated. A well-configured environment saves countless debugging hours later on.

Task 2: Modular Programming, Data Handling & Exceptions — Building Resilience

This task elevated our coding from simple scripts to more resilient and organized applications. We explored:

• *Functions (`args,kwargs`, Lambda): Mastering these allowed for flexible, reusable code.
• File Handling (Read/Write/Append): Essential for any application needing to store data persistently. My contact_manager.py was a practical exercise in this.
• Exception Handling (try/except/else/finally): This taught me that robust code anticipates errors. Handling ZeroDivisionError in my exception_handling.py was a prime example of making code "fail gracefully."
• Data Structures: Deep diving into Lists, Tuples, Sets, and Dictionaries, along with list/dictionary comprehensions, proved invaluable for efficient data manipulation in my student_records.py.

My Key Takeaway: Robustness isn’t an afterthought; it’s a design principle. Anticipating potential errors makes code reliable and user-friendly.

Task 3: Object-Oriented Programming (OOP) & Advanced Python — Scaling Up

This was a pivotal moment, introducing us to paradigms that empower large-scale development.

• OOP Concepts: Building a bank_account.py system, I delved into Encapsulation (protecting data like balances) and Inheritance, realizing how these principles simplify complex system design.
• Decorators: The @timer decorator for decorators.py was fascinating. It showed me how to add functionality to existing functions without altering their core code—a powerful concept for logging, authentication, or timing in AI models.
• Generators: My fibonacci_gen and custom_range in generators.py were a revelation. I learned that generators are memory-efficient, especially critical when dealing with the massive datasets common in AI/ML, by yielding values one at a time instead of storing everything in memory.

My Key Takeaway: OOP provides a powerful framework for structuring complex problems, while advanced Python features like decorators and generators are essential tools for writing elegant, efficient, and scalable code.

Task 4: Libraries, Packaging & Production Readiness — Towards Real-World Applications

This task was about “professionalizing” our code. It moved us beyond individual files to thinking about entire project architectures.

• Modularization: Converting previous scripts into dedicated modules (math_utils.py) taught me the value of separation of concerns.
• Custom Python Packages: Creating mypackage with its __init__.py file was a significant step. This is how real libraries are built, allowing us to group related functionalities and import them cleanly.
• Dependency Management: Regularly updating requirements.txt became a habit, ensuring anyone could replicate my environment.
• Logging vs. Print: Replacing print() statements with the logging library was a crucial shift for production-grade code, offering better control over output and error tracking.

My Key Takeaway: A well-structured, properly packaged, and documented project isn’t just “good practice” — it’s a necessity for collaboration, maintainability, and deployment in the real world.

Mini Project: Bringing It All Together with Streamlit!

The week culminated in a mini-project: a “Fellowship Study & Expense Tracker” using Streamlit. This was the perfect exercise in synthesis. We had to apply:

• OOP (StudyEntry, TrackerManager classes).
• File/Error Handling (saving/loading data to logs.csv safely).
• Modular Design (a dedicated logger_pkg for logic).
• Streamlit Integration: Creating an interactive web interface to log study hours and display progress.

It was incredibly satisfying to see all the individual concepts from the week converge into a functional, user-friendly application.

My Key Takeaway: Practical application solidifies theoretical knowledge. Streamlit is an amazing tool for quickly visualizing and interacting with Python backend logic.

Looking Ahead: What’s Next?

Week 1 has been a rigorous but incredibly rewarding experience. I’m excited to carry these foundational Python, Git, and software engineering principles into Week 2, where we’ll undoubtedly dive deeper into the fascinating world of Machine Learning algorithms and concepts.

A huge thank you to the GDG Open Cloud Fellowship for providing such a structured and challenging learning environment!

You can view my complete Week 1 progress on GitHub here: https://github.com/hammadali155/AI-ML-Fellowship-GDGOC-2026

#GDGOpenCloud #AIFellowship #MachineLearning #Python #SoftwareEngineering #Streamlit #Week1