Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
Python · Question Set
Memory, Copying & Performance interview questions for placements and exams.
Questions
15
Included in this set
Subject
Python
Explore more sets
Difficulty
Mixed
Level of this set
Go through each question and its explanation. Use this set as a focused practice pack for Python.
copy.copy makes a shallow copy. copy.deepcopy walks the entire object graph and copies inner containers too. For custom classes, you can guide deep copy with __deepcopy__ if you need special handling.
import copy b = copy.deepcopy(a)
For complete preparation, combine this set with full subject-wise practice for Python. You can also explore other subjects and sets from the links below.
Lists are mutable and can be changed in place. Tuples are immutable and cannot be changed after creation. Understanding mutability is key to safe copying, hashing, and function argument behavior.
lst=[1,2]; lst.append(3) tup=(1,2) # cannot append
getsizeof returns the shallow size of the object in bytes. It does not include sizes of nested objects it references. To estimate full footprint, you must traverse the object graph and sum sizes manually or use third party tools.
import sys print(sys.getsizeof([1,2,3]))
Implementations like CPython cache a range of small integers to reduce allocations. This makes repeated small numbers share the same identity. It is an implementation detail, not a language guarantee. Do not rely on it for program logic.
a=5; b=5 print(id(a)==id(b)) # often True
bytes is immutable. bytearray is mutable and lets you edit binary data without creating new objects. For zero-copy slicing of existing buffers, wrap with memoryview to avoid extra allocations.
buf = bytearray(b'ABC') buf[0]=97 # a
memoryview exposes a shared view of the underlying buffer. Slices do not allocate new memory, which helps performance. It is useful for protocols, image processing, and when slicing large binary payloads.
data=b'x'*1_000_000 mv=memoryview(data) chunk=mv[100:200]
timeit runs a statement many times and reports stable timing by reducing noise. It is ideal for comparing small code snippets. For finding hot functions in a program, use cProfile. For memory tracking, use tracemalloc.
import timeit
print(timeit.timeit('sum(range(1000))', number=1000))CPython primarily uses reference counting. Each object tracks how many references point to it. When the count drops to zero, the object is freed immediately. This makes most reclamation prompt and predictable. Reference cycles cannot be collected by counting alone, so a cyclic garbage collector runs occasionally to find groups of objects that reference each other but are otherwise unreachable. You can tune collection thresholds with the gc module, but most apps do not need manual tweaks. Be careful with objects that define finalizers; cycles containing them may not be collected automatically. Breaking cycles with weak references or context managers keeps memory healthy.
import gc print(gc.get_threshold()) # gc.collect() can force a cycle collection
A weak reference lets you refer to an object without increasing its reference count. When the object is reclaimed, the weak reference becomes dead. This avoids memory leaks caused by accidental strong reference cycles. Use weak references for caches, observer lists, and graphs where you do not own the lifetime. They allow objects to disappear naturally when nothing else needs them.
import weakref class A: pass obj=A() w=weakref.ref(obj) obj=None # target can be collected
Start with measurement, not guesses. Use cProfile to collect function level timings and inspect results with pstats or snakeviz. Focus on the few functions that dominate total time, often called the vital few. Apply targeted fixes: reduce algorithmic complexity, move heavy loops out of Python into vectorized libraries, or cache pure results. Re-measure after each change to confirm real wins and to avoid regressions.
import cProfile, pstats
cProfile.run('main()', 'prof')
p=pstats.Stats('prof'); p.sort_stats('tottime').print_stats(20)del only deletes a name binding. If other references still exist, the object stays alive. When the last reference goes away, CPython frees it, or the cycle collector reclaims it later if part of a cycle. To diagnose leaks, track object counts over time with tracemalloc or objgraph like tools. Look for growing containers, cache keys that never expire, or reference cycles involving long lived objects.
import tracemalloc tracemalloc.start() # run workload print(tracemalloc.get_traced_memory())
A shallow copy creates a new outer container but keeps references to the same inner objects. Editing an inner list through the copy also changes the original. A deep copy recursively copies inner structures, so changes in the copy do not leak back. Pick deep copy when you need isolation.
import copy orig=[[1],[2]] sh=copy.copy(orig) dp=copy.deepcopy(orig) sh[0][0]=9 # orig also changes # dp edits do not affect orig
__slots__ removes the per-instance dictionary and stores fields in a fixed structure. This cuts memory per instance and can make attribute lookups a bit faster. It also limits dynamic attribute creation unless you include __dict__ in slots.
class Row:
__slots__=('a','b')
def __init__(self,a,b): self.a=a; self.b=bReplace loops when you are doing simple numeric or array transformations that map well to C level operations. Libraries such as NumPy run inner loops in optimized C, often giving big speedups. Even without NumPy, prefer built-ins like sum, min, max, any, all, and list comprehensions over manual loops. They are faster, clearer, and implemented in C where possible.
nums=list(range(1_000_000)) # better total=sum(nums) # with numpy # import numpy as np; total=np.sum(np.array(nums))
Threads work best for I O bound tasks, like network calls or disk waits. While one thread blocks, others can run, and the program makes progress. The Global Interpreter Lock limits true parallel CPU execution, but I O overlap still helps a lot. For CPU bound work, use multiprocessing to run multiple processes that bypass the Global Interpreter Lock. Share data carefully, batch work to reduce pickling costs, and consider using native extensions when possible.
# I O bound: threading # CPU bound: multiprocessing # mix with concurrent.futures for a simple API