DEV Community: still-purrfect

📖 DICTIONARIES IN PYTHON: THE SMART DATA VAULT

still-purrfect — Thu, 28 May 2026 11:43:57 +0000

In our last stop, we explored tuples
those neat, ordered, and unchangeable containers that keep data safe but a bit rigid.
But what happens when you don’t just want to store data…you want to label it, search it, and instantly retrieve it like a pro?

That’s where dictionaries step in.
If tuples are like a fixed checklist, then dictionaries are more like a smart contact list in your phone you don’t scroll randomly, you just search a name and boom, you get exactly what you need.

A dictionary in Python is a built-in data structure used to store data in key–value pairs.

Think of it like this:

🗝️ Key = the label (what you search with)
📦 Value = the actual data stored

🧠 Basic Structure

student = {
    "name": "Maryanne",
    "age": 20,
    "course": "Computer Science"
}

Here:

"name" → key
"Maryanne" → value

⚙️Why Dictionaries Matter
In real systems, dictionaries are everywhere:

User profiles in apps
Configuration settings
APIs returning JSON data
Databases mapping IDs to records Basically, if software needs to quickly look something up, dictionaries are usually behind the scenes.

🚀 Key Features of Dictionaries

🔑 Key–Value Pair System
Everything is stored as a pair.
```
  "username": "coder123"
```
⚡ Fast Lookup
Instead of searching step-by-step, Python goes:

“Give me the key → I’ll give you the value instantly.”
🔄 Mutable (Editable)
You can change values anytime.
```
   student["age"] = 21
```
🚫 No Duplicate Keys

Each key is unique. If you repeat a key, the latest value replaces the old one.

🧩 Accessing Data

print(student["name"])

Output:

Maryanne

You don’t “search through” the dictionary you call the key directly like an API request.

🛠️ Common Dictionary Operations
➕ Adding Data

student["grade"] = "A"

✏️ Updating Data

student["course"] = "Software Engineering"

❌ Removing Data

del student["age"]

🔍 Checking Keys

"name" in student

Returns:

True

🧠 Real-Life Analogy
Imagine a database system:

Keys = Primary Index (like User ID)
Values = User data stored in rows Instead of scanning every record (slow), dictionaries use direct access mapping (fast and efficient). That’s basically how:
Web apps
Backend systems
Cloud services stay fast even with millions of users.

💡 Why Developers Love Dictionaries
Because they:

Reduce complexity
Make code cleaner
Speed up data retrieval
Mirror real-world structured data (like JSON)

🔗 Mini Link Back to Tuples
Unlike tuples, which are:

ordered
fixed
unchangeable Dictionaries are:
flexible
labeled
dynamic So if tuples are locked memory snapshots, dictionaries are live smart systems constantly updating in real time.

🧪 Final Thought
If programming had a “thinking brain” data structure, it would be dictionaries. Because they don’t just store data they understand how to retrieve it instantly.
Github Repo:

Tuples in Python (something I almost ignored)

still-purrfect — Thu, 28 May 2026 08:04:01 +0000

I recently shared what I learned about lists, and while I was getting comfortable with them, I came across tuples. They just looked like lists with different brackets, they felt unnecessary… but I was wrong 😅
👉 You can read my post on lists here:

What I thought at first
I was mostly using lists like this:

numbers = [1, 2, 3]

Then I saw tuples:

numbers = (1, 2, 3)

And I was like… okay? What’s the difference?

What I later realized
The main difference is simple:
👉 You can change a list
👉 You can’t change a tuple
That’s it.
At first, that felt like a disadvantage.
But then I started thinking about it differently.

A small example
Let’s say I have coordinates:

coordinates = (10.5, 20.3)

These values are not supposed to change.
So using a tuple actually makes sense here.
It’s like saying:
“This is fixed.”

Something I didn’t expect
Functions can return tuples without you even noticing:

def get_user():
    return "Maryanne", 21

name, age = get_user()

When I first saw this, I didn’t even know that was a tuple 😅

My takeaway (so far)
I’m still learning, but this is how I see it now:

Use a list when things might change
Use a tuple when things should stay the same It’s a small thing, but it actually makes your code clearer.

Final thought
I used to think tuples were unnecessary.
Now I see them as a simple way to be more intentional with my code.
Still learning, but I thought I’d share this in case someone else is confused like I was.

If you’re also learning Python, did tuples make sense to you immediately, or did they confuse you at first?
Each step has been building on the last and after tuples, dictionaries felt like a real shift.
Now I’m not just storing data, I’m organizing it with purpose.
👉 I wrote about dictionaries here if you want to check it out:
Explore the code behind this on my Github Repo:

Python Lists (one of the first things that actually made sense)

still-purrfect — Thu, 28 May 2026 07:04:02 +0000

When I started learning Python, lists were one of the first things that actually clicked for me. They’re simple, but also really useful.
Before this, I was learning about variables and how to store single values. Lists felt like the next step storing multiple values in one place.
👉 If you missed it, you can read about variables here:

What is a list?
A list is just a way to store multiple values in one place.

numbers = [1, 2, 3]

That’s it.
Instead of creating many variables, you just put everything inside one list.

Why I like lists
The best part about lists is that you can change them.
You can add things:

numbers = [1, 2, 3]
numbers.append(4)

You can remove things:

numbers.remove(2)

You can even change values:

numbers[0] = 10

This made lists feel very flexible compared to other things I’ve learned so far.
A simple example
Let’s say I want to store names:

names = ["Maryanne", "John", "Aisha"]

If I want to get the first name:

print(names[0])

At first, the [0] was confusing, but I’m getting used to it now.

What I’m starting to notice
Lists are good when your data might change.
Like:

Adding new items
Removing items
Updating values That’s probably why they’re used a lot.

My takeaway (so far)
Lists are:

Easy to understand
Easy to use
Very flexible I feel like they’re one of those things you’ll keep using over and over again.

Final thought
I’m still learning, but lists made Python feel a bit less scary for me.
If you’re just starting out, this is one of those topics that’s worth practicing a lot.

If you’re learning Python too, what was the first concept that actually made sense to you?
I also explored tuples (which confused me at first 😅):
👉 Read it here:
Explore the code behind this on my Github Repo:

🧠 Python Variables: The Tiny Containers That Run Everything You See in Code!

still-purrfect — Tue, 26 May 2026 10:21:30 +0000

Before Python became Python… before apps, websites, AI… there was something small holding everything together: variables.

And honestly, that’s where most beginners underestimate power.

Let’s fix that.

🧩 Imagine This for a Second…

You walk into a room.

Everything is labeled:

📦 “Name: Maryanne”
📦 “Age: 21”
📦 “Height: 5.6”

Nothing is random. Everything is stored, named, and ready to be used.

That’s exactly what a variable is in Python.

A labeled container for data.

Simple. But powerful.

🧪 So… What Is a Variable?

In Python, a variable is created the moment you assign a value:

name = "Maryanne"
age = 21
height = 5.6

No declaration. No complexity. Just assignment.

That’s called dynamic typing, but don’t overthink it just means Python is smart enough to figure things out for you.

⚡ Why Should You Even Care?

Because variables are not “just basics.”
They are:
🧠 Memory holders
🔁 Reusable data points
🧱 Building blocks of every program you’ll ever write

Without variables, your code would forget everything instantly.
And that would be… chaos.

🎯 A Real-Life Example
Let’s say you’re tracking a student:

student_name = "Maryanne"
marks = 85

print(student_name)
print(marks)

Now imagine scaling that:
1 student → easy
100 students → still manageable
1 million students → only possible because variables exist
That’s the difference.

Python is flexible, but there are still rules:
✔ Good naming

user_name = "John"
totalMarks = 90

❌ Bad naming

1name = "John"      # starts with number
user name = "John"  # space inside name

💡 A Small Truth Most Tutorials Don’t Tell You
Variables are not about syntax.
They are about thinking like a programmer

🔥 Final Thought
If programming feels overwhelming right now, it shouldn’t.
Because every complex system you’ve seen; apps, games, AI is just a lot of simple variables working together.

Start there. Build from there.
Everything else is just layers.
And now that we know about variables, we can move on to how we store multiple values together using lists. Continue here:

🧠Feel free to live a comment or ask a question.