Why Python? — My Honest Take

A quick note before I begin — I'm not here to say Python is the best language out there. Every language has its place, its purpose, and its strengths. This is just my experience.

Before Python

I started with C in my first year — basics, arrays, stacks, queues. Two semesters of it, and honestly, I enjoyed it. Not because C is glamorous, but because I had the time to actually sit with it, think through the logic, and solve problems. That feeling of figuring something out — I liked that.

Then every semester brought something new. DSA in C++, OOP in Java, Web Tech with HTML, CSS, JS and React. Each time, I knew enough theory to get through but never really got it. The problem was always the same — I never understood the why, and did not give time required. What problem is this solving? Why does this exist? Without that anchor, nothing stuck.

I had used Python before too — for linear algebra and some basic EDA in earlier sems — but again, without understanding the why, it didn't go anywhere.

Then in 5th semester, I had an ML and Computer Vision project. That's when I found Nitish sir's (Nitish Singh's) channel, CampusX. He always starts with the why — the intention behind a tool, what existed before it, what problem it actually solves. That approach clicked for me. Now in my 6th semester, four to five months into his Python videos, I'm genuinely enjoying it.

Python — Easy to Write, Easy to Think In

The first thing I noticed when I started writing Python was how clean it looks. Everything is indented — not as a style choice, but as a rule. That alone makes reading and debugging so much easier. You can glance at code and immediately understand the structure.

# C needs curly braces, semicolons, and headers
# Python just uses indentation

age = 20

if age >= 18:
    print("You can vote!")  # inside the if block
else:
    print("Not yet.")       # inside the else block

No curly braces. No semicolons hunting you down. The code just says what it means.

But what really stood out was how Python handles variables. If you've ever declared an array in C or C++, you know the drill — you mention the data type, fix the size, and that variable is locked to that purpose. Need something different? Start over. In Python, none of that exists. A variable can hold a list, a dictionary, a custom object, or a number — and you can change what it holds freely. You never mention the type anywhere. Python looks at the value and figures it out itself. This is called dynamic typing.

x = [1, 2, 3]       # x is a list
print(type(x))       # <class 'list'>

x = 42               # now x is an integer — no error, no drama
print(type(x))       # <class 'int'>

x = "hello"          # now a string
print(type(x))       # <class 'str'>

In C, that second line would be an error. In Python, it just works.

And dynamic binding — the ability of a variable to hold different types at different points — is more useful than it first sounds. When I was working with a large dataset in Pandas, tens of thousands of rows, I used astype() to convert int64 columns to int32, and strings to the category type. Same variable, different type, less memory, faster processing.

import pandas as pd

df = pd.read_csv("data.csv")

# before optimization
print(df.dtypes)
print(df.memory_usage(deep=True))

# convert to save memory
df["age"] = df["age"].astype("int32")        # int64 → int32
df["city"] = df["city"].astype("category")   # string → category

# after — noticeably less memory
print(df.memory_usage(deep=True))

Even something as simple as a loop shows this — the variable i takes on each element one by one, whatever type that element happens to be. Dynamic binding is quietly doing the work every time.

data = [1, "hello", 3.14, True]  # a list holding different types

for i in data:
    print(i, "→ type:", type(i))

# Output:
# 1 → type: <class 'int'>
# hello → type: <class 'str'>
# 3.14 → type: <class 'float'>
# True → type: <class 'bool'>

That freedom gives you room to actually think about the problem — not fight the language.

The Ecosystem — A Library for Everything

One thing that genuinely amazed me was how far Python stretches. It isn't just a language — it's an entire ecosystem built around the intention of getting things done quickly and moving on to next task.

Need to work with data? Pandas and NumPy. Visualise it? Matplotlib, Seaborn. Build a neural network? PyTorch. Connect to an LLM, build an agentic workflow? LangChain, LangGraph. Backend API? FastAPI. Computer vision? OpenCV. The list keeps going.

Almost all of these are open source, modular, and built with enough abstraction that a beginner can start using them without needing to understand what's happening under the hood — unless they want to. I didn't need to understand how PyTorch builds a computation graph to train my first model. I just needed to know how to use it.

And they're all still actively evolving. That's something I find genuinely exciting as someone still learning — the tools are growing at the same time I am.

Why I'm Writing This

I'm not writing this to teach. I'm still learning.

But writing does something that just watching or reading doesn't — it forces you to actually understand. To write this post, I had to go back and ask myself why again. Why does dynamic typing work this way? Why does this library exist? That process gave me more clarity than hours of passive learning.

I intend become someone who understands how and why, not someone who just knows things. This blog is part of that.

Next, I'm planning to write about OOP in Python — which, unlike Java, actually made sense to me. After that, Python's other interesting bits like generators, mutability, and what makes them useful. Then maybe DSA, and eventually the libraries I've been using.

See you in the next one.

written with AI assistance