DEV Community: Aditya

Python mutable default arguments: why your list keeps growing (tested examples)

Aditya — Wed, 14 Oct 2026 05:55:54 +0000

A list that keeps growing between function calls is one of the most common Python surprises in exams and interviews. Here is why it happens, with output I ran on Python 3.10.

The bug

def add_bad(x, bucket=[]):
    bucket.append(x)
    return bucket

print(add_bad(1))
print(add_bad(2))
print(add_bad(3))

Output:

[1]
[1, 2]
[1, 2, 3]

You expected [1], [2], [3]. Python builds the default value once, when def runs, not on each call. Every call that skips bucket reuses the same list. You can see it:

print(add_bad.__defaults__)   # ([1, 2, 3],)

The fix

Use None as the default and create the list inside the function.

def add_ok(x, bucket=None):
    if bucket is None:
        bucket = []
    bucket.append(x)
    return bucket

print(add_ok(1))   # [1]
print(add_ok(2))   # [2]

Same family: shallow copies

list.copy() copies only the outer list. The inner lists are shared.

import copy
a = [[1, 2], [3, 4]]
b = a.copy()
b[0].append(99)
print(a)             # [[1, 2, 99], [3, 4]]  a changed too

c = copy.deepcopy(a)
c[0].append(5)
print(a, c)          # a is unchanged by c

Same family: the grid trap

grid = [[0] * 3] * 2
grid[0][0] = 7
print(grid)    # [[7, 0, 0], [7, 0, 0]]  both rows are one list

grid2 = [[0] * 3 for _ in range(2)]
grid2[0][0] = 7
print(grid2)   # [[7, 0, 0], [0, 0, 0]]

[x] * n repeats a reference to the same object. A list comprehension builds a new row each time.

Quick rule

Never use a list, dict or set as a default argument. Use None.
copy() and slicing are shallow. Use copy.deepcopy for nested data.
Build 2D grids with a comprehension, not *.

Try to predict the output of each snippet before you run it. That habit is what exam questions test.

I wrote a longer version with 7 more tested examples and exam-style questions here: Python Mutable Default Arguments and Shallow Copies. It is part of TechVani, a free BTech CSE notes and lab-files site.

Average memory access time with a cache: formula and a worked example

Aditya — Mon, 05 Oct 2026 05:08:39 +0000

Average memory access time (AMAT) tells you how fast a memory system is on average, once you account for cache hits and misses.

For one cache level plus main memory, with hit ratio h, cache access time Tc and main memory time Tm:

If memory is accessed only after a miss is detected: AMAT = h x Tc + (1 - h) x (Tc + Tm)
If cache and memory are accessed in parallel: AMAT = h x Tc + (1 - h) x Tm

Example: h = 0.9, Tc = 10 ns, Tm = 100 ns. With the sequential formula, AMAT = 0.9 x 10 + 0.1 x 110 = 20 ns. Parallel access gives 0.9 x 10 + 0.1 x 100 = 19 ns.

The exam trap is picking the wrong formula, so always check whether the question says the memory is accessed after a miss or simultaneously.

I wrote up 6 more solved numericals (including multi-level cache and effective CPI) on my blog TechVani: https://techvaniai.blogspot.com/2026/10/cache-memory-numericals-6-solved.html

Round Robin vs SJF: a worked scheduling example you can redo by hand

Aditya — Thu, 01 Oct 2026 18:33:47 +0000

Scheduling questions in OS exams look scary, but the method is the same every time: draw the Gantt chart, then read waiting time and turnaround time off it.

Take 3 processes, all arriving at time 0:

Process	Burst
P1	6
P2	2
P3	4

SJF (non-preemptive): run the shortest first: P2 (0-2), P3 (2-6), P1 (6-12).
Waiting times: P2 = 0, P3 = 2, P1 = 6. Average = 8/3 = 2.67.

Round Robin, quantum = 2: P1 (0-2), P2 (2-4), P3 (4-6), P1 (6-8), P3 (8-10), P1 (10-12).
Waiting time = finish - burst: P1 = 12 - 6 = 6, P2 = 4 - 2 = 2, P3 = 10 - 4 = 6. Average = 14/3 = 4.67.

So SJF gives the lower average wait here, but it can starve long jobs. Round Robin is fairer and has better response time, at the cost of more context switches.

Tips: always list arrival times first, mark the quantum on the chart, and check that the total of all bursts equals the last finish time.

I also made a full OS revision video (processes, scheduling, deadlock, memory, file systems) in Hinglish, about 96 min: https://www.youtube.com/watch?v=RSR2sqyR5pE

More notes and videos on Telegram: https://t.me/techvaniai