Lessons from Python, Pandas, and Git

When I started working with Python and data science, much of my attention was on learning the tools: writing code, manipulating data, building models, and getting things to work.

Over time, through projects and preparing teaching materials, I started appreciating something else.

The tools themselves are important, but the habits you develop while using them matter even more.

Looking back at my Python, Pandas, and Git notebooks, three lessons stand out.

1. Python: Understanding beats memorising

Python was my entry point into practical data science.

I spent time exploring the fundamentals: data structures, functions, classes, NumPy, and visualisation with Matplotlib.

One thing I came to appreciate is that knowing Python syntax isn't the same as understanding how a program runs and behaves.

That means following a program step by step, understanding why some data structures are faster for particular tasks, and knowing when vectorised operations in libraries such as Pandas can replace Python loops with efficient compiled code. Understanding how and why code runs is more useful than memorising syntax.

Jupyter Notebooks are a good example. They're excellent for experimentation, but they also make it easy to execute cells out of order, depend on hidden variables, or end up with code that only works in your current session.

A notebook that runs isn't necessarily a notebook that someone else can reproduce.

The lesson: Write code for understanding and reproducibility, not just for getting the expected output.

2. Pandas: Understand your data before analysing it

Pandas makes data manipulation surprisingly accessible. A few lines of code can filter thousands of records, calculate statistics, or produce visualisations.

But that convenience introduces another challenge: it's easy to generate convincing results without understanding the underlying data.

In my Pandas tutorial, I used the Titanic dataset to explore some fundamental operations: inspecting columns, examining data types, identifying missing values, filtering observations, and aggregating data.

These might seem like basic tasks. Yet they're often where important analytical decisions begin.

What does a missing value represent? Does a group average tell the whole story? Are we comparing populations that are genuinely comparable?

The more I worked with data, the more I appreciated the importance of asking these questions before moving on to modelling.

The lesson: A good analysis begins with curiosity about the data, not with selecting an algorithm.

3. Git: Good engineering is also about collaboration

Git introduced a different dimension to working with code.

At first glance, version control is about commands: add, commit, push, pull, branch, and merge.

But its real value is much broader.

It provides a way to experiment without losing previous work, understand why something changed, and collaborate without everyone overwriting each other's contributions.

The concepts behind Git, such as making small logical commits, working in branches, and resolving conflicts, are valuable beyond software development. They encourage a more structured approach to technical work.

And as projects become larger, these habits become increasingly important.

The lesson: Code shouldn't just work today. It should be understandable, maintainable, and safe to change tomorrow.

Bringing the three together

None of these lessons is particularly glamorous. They don't involve the latest model architecture or a groundbreaking algorithm.

Yet they form part of the foundation for more advanced work, whether that's developing machine learning systems, building data products, or experimenting with AI agents.

As my interests have evolved toward applied AI and engineering, I've found these fundamentals increasingly relevant.

Technology changes quickly. Good working habits tend to last much longer.