DEV Community: Pavitha P

That One Python List Bug That Wasted My Time 😅

Pavitha P — Wed, 24 Dec 2025 02:29:38 +0000

I recently ran into a weird Python bug while solving a problem that needed a 2D list.
Everything looked correct, but the output was completely wrong.

Turns out, it was this one line:

index = [[0, 0]] * n

If you’ve written Python for a while, you might already know where this is going.

What I Thought This Did

I thought this would create n rows, each with [0, 0].

Something like:

[
  [0, 0],
  [0, 0],
  [0, 0]
]

Reasonable assumption.
Totally wrong assumption.

What It Actually Does

Python doesn’t create n separate lists here.

It creates one list [0, 0]
and then repeats the reference to it n times.

So all rows point to the same object.

Here’s the proof:

index = [[0, 0]] * 3
index[0][0] = 7
print(index)

Output:

[[7, 0], [7, 0], [7, 0]]

I changed one value… and every row changed.
That’s when I knew something was off.

Why This Happens

The * operator does a shallow copy.

Internally, Python is basically doing:

index = [same_list, same_list, same_list]

So modifying one row means modifying all of them.

The Fix (And the Right Way)

The correct way is using a list comprehension:

index = [[0, 0] for _ in range(n)]

This creates new lists every time, not shared ones.

Quick check:

index = [[0, 0] for _ in range(3)]
index[0][0] = 7
print(index)

Output:

[[7, 0], [0, 0], [0, 0]]

Exactly what we want.

When `*` Is Actually Fine

Using * is totally okay with immutable values:

arr = [0] * 5   # perfectly fine

The problem only starts when you use it with nested mutable objects like lists.

🚀 StoryCloak – Looking for Developer Feedback & Suggestions 🙌

Pavitha P — Sun, 10 Aug 2025 08:29:36 +0000

Hey Dev Community! 👋

I just finished building my very first Flask project StoryCloak — a secure, full-featured web app for sharing microstories.
While I’m super excited about it, I know there’s always room for improvement, and that’s why I’m here:

I’d love to get feedback from fellow developers — on the code, structure, features, or even the UI/UX.

🌐 Try it here:

https://storycloak.onrender.com

📂 GitHub Repo: https://github.com/pavithapari/StoryCloak

🔹 What’s Inside

User authentication with email confirmation

Secure password hashing & login system

Flask-Migrate for smooth DB migrations

Organized, scalable project structure

Bootstrap + HTML + CSS for frontend

SQLAlchemy ORM for database handling

PostgreSQL for production (hosted on Render)

Deployed on Render’s free tier

🎯 What I’m Looking for Feedback On

Code structure: Is it organized enough for long-term scaling?

Database design: Any optimizations or pitfalls you see?

Security: Did I miss any best practices?

UI/UX: Is it smooth and user-friendly?

Feature suggestions: What would make the app more engaging?

💬 I’m open to any constructive criticism — the goal is to make StoryCloak better while also leveling up my own skills as a backend developer.

If you have a moment, please:

Try the app
Share a story or note
Let me know what you think in the comments!

#flask #python #backend #webdevelopment #projectfeedback #learninginpublic

PRG pattern

Pavitha P — Sat, 12 Jul 2025 14:17:44 +0000

🌀 Demystifying POST–REDIRECT–GET in Flask

Ever submitted a form in your Flask app and then hit refresh—only to get a browser warning about resending data? Welcome to the world of POST resubmission, a sneaky little side effect that’s solved beautifully by the Post–Redirect–Get (PRG) pattern.

Let’s break it down 👇

📬 The Problem with POST: Form Resubmission

Imagine this flow:

User fills out a form (e.g., update profile).
You handle the form with POST.
You use render_template() to show the dashboard directly.
Then... the user refreshes the page.

🔁 Result: The browser resubmits the form, triggering a second POST!

This can:

Cause duplicate database writes
Repeat email or username changes
Show misleading flash messages again
Annoy users with “Confirm form resubmission” alerts

✅ Enter the Hero: Post–Redirect–Get (PRG)

Instead of rendering the updated page right after the POST, PRG introduces a redirect step so the browser only refreshes with a safe GET.

PRG flow:

POST → Redirect → GET

✨ Example: Updating Profile

@app.route('/account', methods=['GET', 'POST'])
@login_required
def account():
    form = UpdateProfileForm()
    if form.validate_on_submit():
        current_user.username = form.username.data
        current_user.email = form.email.data
        db.session.commit()
        flash('Your account has been updated!', 'success')
        return redirect(url_for('account'))  # 🔄 Redirect fixes refresh bug
    return render_template('dashboard.html', form=form, user=current_user)

📌 Why This Works

User submits form → POST runs and updates DB
Server sends a redirect to /account
Browser follows redirect → does a GET
Refreshing now re-runs the GET, not the form submission

🧪 Bonus Tip: Use DevTools to Watch the Flow

In your browser's developer tools:

Check the Network tab
Watch for the POST request, followed by a 302 Found redirect
The next request will be GET—clean and safe for refreshes

Data Types, Data Structures, and Abstract Data Types – What’s the Difference

Pavitha P — Fri, 27 Jun 2025 03:49:57 +0000

🔹 Data Types — “What Kind of Data?”
Data types define what kind of data a variable can hold. They form the most basic units of any program.
Examples:

int — whole numbers
float — decimal numbers
char — single characters 💡 Think of these as the building blocks of data.

🔹 Data Structures — “How Is Data Organized?”
Data structures define how data is arranged and stored in memory. They allow for efficient access and manipulation.
Examples:

Arrays
Linked Lists
Trees 💡 These are the containers that hold and structure the building blocks.

🔹 Abstract Data Types (ADTs) — “What Can You Do With It?”
ADTs describe the behavior and operations that can be performed on data, without specifying how they’re implemented. They’re more about what you can do rather than how it’s done.
Examples:

Stack (push(), pop())
Queue (enqueue(), dequeue()) 💡 Think of ADTs as blueprints—they define expected behavior while leaving implementation details open.

✨ Wrap-Up
In short:

Data Types 🧱 define the kind of data
Data Structures 📦 organize the data
ADTs 🛠️ define operations you can perform Together, these form the foundation of how we model, store, and manipulate information in programming. Have thoughts or questions? Let’s connect in the comments! 💬