Python Notes
HubHistory of Python - Complete Guide 2026Python Applications - Complete Guide 2026Python Features - Complete Guide 2026What is Python? - Complete Guide 2026Why Learn Python? - Complete Guide 2026Your First Python Program – Hello World & Beyond 2026How to Install Python on Windows, Mac & Linux – Complete Guide 2026Install VS Code for Python – Complete Setup Guide with Extensions 2026Python Environment Setup – Virtual Environments, pip & Project Structure 2026Python IDLE – Complete Guide for Beginners 2026Python CommentsPython Data TypesPython Input and OutputPython OperatorsPython SyntaxPython Strings BasicsPython Type CastingPython VariablesBreak, Continue and Pass in PythonElif Statement in PythonFor Loop in PythonIf-Else Statement in PythonIf Statement in PythonNested If in PythonPattern Programs in PythonWhile Loop in PythonDecorators in PythonFunction Arguments in PythonFunctions Basics in PythonGenerators in PythonLambda Functions in PythonRecursive Functions in PythonReturn Statement in PythonScope of Variables in PythonAbstraction in PythonClasses and Objects in PythonConstructors in PythonEncapsulation in PythonInheritance in PythonMagic Methods (Dunder Methods) in PythonMethod Overriding in PythonPolymorphism in PythonPython Comprehensions – List, Dict, Set & GeneratorPython Dictionaries – Key-Value StorePython Dictionary Methods – Complete ReferencePython List Methods – All Built-in MethodsPython Lists – Complete GuidePython Set Methods – Complete ReferencePython Sets – Unordered Unique CollectionsPython Tuples – Immutable SequencesPython Asynchronous Programming with asyncioPython Context ManagersAdvanced Python DecoratorsAdvanced Python GeneratorsPython Iterators - Advanced GuidePython Memory ManagementPython MultiprocessingPython MultithreadingCRUD Operations in Python DatabasesMySQL with Python (mysql-connector-python)ORM Introduction with SQLAlchemyPostgreSQL with Python (psycopg2)SQLite3 with PythonIntroduction to DjangoDjango Models and ORMDjango REST API with DRFDjango ViewsIntroduction to FlaskFlask RoutingFlask Templates with Jinja2Email Automation with PythonPDF Automation with PythonSelenium Web Automation with PythonTask Scheduler with PythonWeb Scraping with PythonData Analysis with PythonData Cleaning with PythonData Visualization ProjectData Visualization with MatplotlibNumPy IntroductionPandas IntroductionStatistical Visualization with SeabornClassification AlgorithmsClustering AlgorithmsIntroduction to Machine LearningMachine Learning Project: Churn PredictionModel Evaluation and SelectionRegression AlgorithmsSave pipeline (includes preprocessing + model)AI Assistant ProjectCalculator ProjectChatbot ProjectExpense Tracker ProjectFace Detection ProjectPassword Generator ProjectWeather App ProjectPython Coding Interview QuestionsPython OOP Interview Questions and AnswersPython Master CheatsheetPython Interview Questions and AnswersPython Best PracticesCommon Python Errors and SolutionsPython Debugging TechniquesPython Learning Resources
Python Dictionary के सभी built-in methods का complete reference – get, keys, values, items, update, pop, popitem, setdefault, copy, clear, fromkeys – examples और time complexity के साथ।
Quick Reference Table
| Method | Syntax | Description | Returns |
|---|---|---|---|
get() | d.get(key[, default]) | Safe key access | Value or default |
keys() | d.keys() | All keys | dict_keys view |
values() | d.values() | All values | dict_values view |
items() | d.items() | All (key, value) pairs | dict_items view |
update() | d.update(other) | Merge/update | None |
pop() | d.pop(key[, default]) | Remove & return value | Value |
popitem() | d.popitem() | Remove & return last pair | (key, value) tuple |
setdefault() | d.setdefault(key[, default]) | Get or insert default | Value |
copy() | d.copy() | Shallow copy | New dict |
clear() | d.clear() | Remove all items | None |
fromkeys() | dict.fromkeys(keys[, val]) | Create from keys | New dict |
2. keys(), values(), items() – View Objects
ये तीनों methods view objects return करते हैं जो dictionary के साथ live रहते हैं।
Example
inventory = {"apple": 50, "banana": 30, "cherry": 20}
# keys() – all keys
keys = inventory.keys()
print(keys) # dict_keys(['apple', 'banana', 'cherry'])
print(type(keys)) # <class 'dict_keys'>
# values() – all values
values = inventory.values()
print(values) # dict_values([50, 30, 20])
# items() – (key, value) pairs
items = inventory.items()
print(items) # dict_items([('apple', 50), ('banana', 30), ('cherry', 20)])
# Views are LIVE (reflect changes)
inventory["date"] = 15
print(keys) # dict_keys(['apple', 'banana', 'cherry', 'date'])
print(values) # dict_values([50, 30, 20, 15])
# Convert to list
keys_list = list(inventory.keys())
values_list = list(inventory.values())
items_list = list(inventory.items())
# Useful operations
print(sum(inventory.values())) # 115 (total stock)
print(max(inventory, key=inventory.get)) # apple (max value key)
print(min(inventory.values())) # 15
# Check membership
print("apple" in inventory.keys()) # True (better: just "apple" in inventory)
print(50 in inventory.values()) # True
print(("apple", 50) in inventory.items()) # True
# Unpack in for loop
for key, val in inventory.items():
print(f"{key}: {val}")
Output:
Example
dict_keys(['apple', 'banana', 'cherry'])
<class 'dict_keys'>
dict_values([50, 30, 20])
dict_items([('apple', 50), ('banana', 30), ('cherry', 20)])
dict_keys(['apple', 'banana', 'cherry', 'date'])
dict_values([50, 30, 20, 15])
115
apple
15
True
True
True
3. update() – Dict को Merge/Update करना
Example
profile = {"name": "Alice", "age": 25}
# Update with another dict
profile.update({"email": "alice@email.com", "city": "Delhi"})
print(profile)
# {'name': 'Alice', 'age': 25, 'email': 'alice@email.com', 'city': 'Delhi'}
# Update existing key (overwrite)
profile.update({"age": 26})
print(profile["age"]) # 26
# Update with keyword arguments
profile.update(phone="9876543210", country="India")
print(profile.get("country")) # India
# Update with iterable of (key, value) pairs
profile.update([("hobby", "coding"), ("language", "Python")])
print(profile.get("hobby")) # coding
# update() returns None (in-place)
result = profile.update({"x": 1})
print(result) # None
# Merge multiple dicts (Python 3.9+ way)
d1 = {"a": 1}
d2 = {"b": 2}
d3 = {"c": 3}
# Old way
merged = {}
merged.update(d1)
merged.update(d2)
merged.update(d3)
print(merged) # {'a': 1, 'b': 2, 'c': 3}
# Modern way (Python 3.9+)
merged = d1 | d2 | d3
print(merged) # {'a': 1, 'b': 2, 'c': 3}
# Unpacking (Python 3.5+)
merged = {**d1, **d2, **d3}
print(merged) # {'a': 1, 'b': 2, 'c': 3}
# ⚠️ Conflict resolution: last update wins
a = {"x": 1, "y": 2}
b = {"y": 99, "z": 3}
a.update(b)
print(a) # {'x': 1, 'y': 99, 'z': 3} ← b's value wins for 'y'
Output:
| {'name' | 'Alice', 'age': 25, 'email': 'alice@email.com', 'city': 'Delhi'} |
| {'a' | 1, 'b': 2, 'c': 3} |
| {'a' | 1, 'b': 2, 'c': 3} |
| {'a' | 1, 'b': 2, 'c': 3} |
| {'x' | 1, 'y': 99, 'z': 3} |
4. pop() – Key से Value हटाना व Return करना
python example
data = {"name": "Bob", "age": 30, "city": "Mumbai", "job": "Dev"}
# pop() – remove and return value
age = data.pop("age")
print(f"Popped age: {age}") # Popped age: 30
print(data) # {'name': 'Bob', 'city': 'Mumbai', 'job': 'Dev'}
# pop() with default (no error if missing)
result = data.pop("email", "not set")
print(result) # not set
# pop() without default → KeyError if missing
try:
data.pop("salary")
except KeyError as e:
print(f"KeyError: {e}")
# Pattern: process and remove
config = {"host": "localhost", "port": 5432, "debug": True}
host = config.pop("host") # extract and remove
port = config.pop("port")
print(f"Connecting to {host}:{port}")
print("Remaining config:", config) # {'debug': True}
# Use case: stack-like processing
tasks = {"task1": "high", "task2": "low", "task3": "medium"}
while tasks:
task, priority = tasks.popitem() # LIFO
print(f"Processing {task} ({priority})")Output:
| Popped age | 30 |
| {'name' | 'Bob', 'city': 'Mumbai', 'job': 'Dev'} |
| KeyError | 'salary' |
| Connecting to localhost | 5432 |
| Remaining config | {'debug': True} |
5. popitem() – Last Item हटाना
popitem() – last inserted (key, value) pair हटाता और return करता है।
python example
d = {"a": 1, "b": 2, "c": 3}
# popitem() – removes and returns last (LIFO)
item = d.popitem()
print(item) # ('c', 3)
print(d) # {'a': 1, 'b': 2}
item = d.popitem()
print(item) # ('b', 2)
# Empty dict → KeyError
try:
{}.popitem()
except KeyError as e:
print(f"Error: {e}") # dictionary is empty
# Use case: processing items one by one
inventory = {"item1": 100, "item2": 200, "item3": 300}
processed = []
while inventory:
key, val = inventory.popitem()
processed.append((key, val * 1.1)) # apply 10% markup
print("Processed:", processed)Output:
| {'a' | 1, 'b': 2} |
| Error | 'popitem(): dictionary is empty' |
| Processed | [('item3', 330.0), ('item2', 220.0), ('item1', 110.0)] |
6. setdefault() – Get या Insert Default
dict.setdefault(key, default=None)
- Key exists → value return करे (dict change नहीं होती)
- Key missing → default set करे और return करे
Example
d = {"name": "Alice", "age": 25}
# Key exists – returns existing value
val = d.setdefault("name", "Unknown")
print(val) # Alice
print(d) # {'name': 'Alice', 'age': 25} ← unchanged
# Key missing – inserts default and returns it
city = d.setdefault("city", "Delhi")
print(city) # Delhi
print(d) # {'name': 'Alice', 'age': 25, 'city': 'Delhi'}
# setdefault with None default
d.setdefault("email") # default = None
print(d.get("email")) # None
# ✨ Classic use case: grouping
# Group words by first letter
words = ["apple", "banana", "avocado", "blueberry", "cherry", "apricot"]
groups = {}
for word in words:
groups.setdefault(word[0], []).append(word)
print(groups)
# {'a': ['apple', 'avocado', 'apricot'], 'b': ['banana', 'blueberry'], 'c': ['cherry']}
# Compare with defaultdict approach
from collections import defaultdict
groups2 = defaultdict(list)
for word in words:
groups2[word[0]].append(word)
print(dict(groups2)) # same result
# Building nested structure
data = {}
data.setdefault("users", {}).setdefault("alice", {})["role"] = "admin"
print(data) # {'users': {'alice': {'role': 'admin'}}}
Output:
| {'name' | 'Alice', 'age': 25} |
| {'name' | 'Alice', 'age': 25, 'city': 'Delhi'} |
| {'a' | ['apple', 'avocado', 'apricot'], 'b': ['banana', 'blueberry'], 'c': ['cherry']} |
| {'a' | ['apple', 'avocado', 'apricot'], 'b': ['banana', 'blueberry'], 'c': ['cherry']} |
| {'users' | {'alice': {'role': 'admin'}}} |
7. copy() – Shallow Copy
Example
original = {"name": "Alice", "scores": [85, 90, 95], "info": {"age": 25}}
# Shallow copy
shallow = original.copy()
# Top-level changes don't affect original
shallow["name"] = "Bob"
print(original["name"]) # Alice (unchanged)
print(shallow["name"]) # Bob
# But nested objects ARE shared!
shallow["scores"].append(100)
print(original["scores"]) # [85, 90, 95, 100] ← changed!
print(shallow["scores"]) # [85, 90, 95, 100]
shallow["info"]["age"] = 30
print(original["info"]["age"]) # 30 ← nested dict changed!
# For true independence, use deepcopy
import copy
original = {"name": "Alice", "scores": [85, 90, 95]}
deep = copy.deepcopy(original)
deep["scores"].append(100)
print(original["scores"]) # [85, 90, 95] ← unchanged!
print(deep["scores"]) # [85, 90, 95, 100]
# 3 ways to shallow copy dict
d = {"a": 1, "b": 2}
c1 = d.copy() # Method 1
c2 = dict(d) # Method 2
c3 = {**d} # Method 3 (dict unpacking)
Output:
Example
Alice
Bob
[85, 90, 95, 100]
[85, 90, 95, 100]
30
[85, 90, 95]
[85, 90, 95, 100]
8. clear() – सभी Elements हटाना
python example
config = {"host": "localhost", "port": 5432, "debug": True}
print(f"Before clear: {len(config)} items")
config.clear()
print(f"After clear: {config}") # {}
# clear() vs reassignment (reference behavior)
a = {"x": 1, "y": 2}
b = a # same reference
a.clear() # in-place clear
print(a) # {}
print(b) # {} ← b also cleared!
# vs reassignment
a = {"x": 1, "y": 2}
b = a
a = {} # new empty dict assigned to a
print(a) # {}
print(b) # {'x': 1, 'y': 2} ← b unchanged!Output:
| Before clear | 3 items |
| After clear | {} |
| {'x' | 1, 'y': 2} |
9. fromkeys() – Class Method
dict.fromkeys(iterable, value=None) – keys से नया dict बनाता है।
Example
# All keys with same default value
keys = ["name", "age", "city", "email"]
profile = dict.fromkeys(keys, "unknown")
print(profile)
# {'name': 'unknown', 'age': 'unknown', 'city': 'unknown', 'email': 'unknown'}
# Default value None
empty_profile = dict.fromkeys(keys)
print(empty_profile)
# {'name': None, 'age': None, 'city': None, 'email': None}
# From string (unique chars as keys)
d = dict.fromkeys("hello", 0)
print(d) # {'h': 0, 'e': 0, 'l': 0, 'o': 0} (duplicates removed)
# ⚠️ WARNING: Mutable default is shared!
# All keys share the SAME list object!
bad = dict.fromkeys(["a", "b", "c"], [])
bad["a"].append(1)
print(bad) # {'a': [1], 'b': [1], 'c': [1]} ← all changed!
# ✅ Fix: Use dict comprehension for mutable defaults
good = {k: [] for k in ["a", "b", "c"]}
good["a"].append(1)
print(good) # {'a': [1], 'b': [], 'c': []} ← only 'a' changed
# Use case: initialize score board
players = ["Alice", "Bob", "Charlie"]
scoreboard = dict.fromkeys(players, 0)
scoreboard["Alice"] += 10
scoreboard["Bob"] += 5
print(scoreboard) # {'Alice': 10, 'Bob': 5, 'Charlie': 0}
Output:
| {'name' | 'unknown', 'age': 'unknown', 'city': 'unknown', 'email': 'unknown'} |
| {'name' | None, 'age': None, 'city': None, 'email': None} |
| {'h' | 0, 'e': 0, 'l': 0, 'o': 0} |
| {'a' | [1], 'b': [1], 'c': [1]} |
| {'a' | [1], 'b': [], 'c': []} |
| {'Alice' | 10, 'Bob': 5, 'Charlie': 0} |
10. Advanced Patterns
Pattern 1: Counting with get()
Example
text = "hello world hello python world hello"
freq = {}
for word in text.split():
freq[word] = freq.get(word, 0) + 1
print(sorted(freq.items(), key=lambda x: x[1], reverse=True))
# [('hello', 3), ('world', 2), ('python', 1)]
Output
[('hello', 3), ('world', 2), ('python', 1)]Pattern 2: Grouping with setdefault()
Example
students = [
("Alice", "CS"), ("Bob", "Math"), ("Charlie", "CS"),
("Dave", "Physics"), ("Eve", "Math")
]
departments = {}
for name, dept in students:
departments.setdefault(dept, []).append(name)
print(departments)
# {'CS': ['Alice', 'Charlie'], 'Math': ['Bob', 'Eve'], 'Physics': ['Dave']}
Output
{'CS': ['Alice', 'Charlie'], 'Math': ['Bob', 'Eve'], 'Physics': ['Dave']}Pattern 3: Dict as Switch/Case
python example
def process(operation, a, b):
ops = {
"add": lambda: a + b,
"sub": lambda: a - b,
"mul": lambda: a * b,
"div": lambda: a / b if b != 0 else "Error"
}
return ops.get(operation, lambda: "Unknown op")()
print(process("add", 10, 5)) # 15
print(process("mul", 4, 7)) # 28
print(process("xyz", 1, 2)) # Unknown opOutput
15 28 Unknown op
Pattern 4: Invert a Dictionary
Example
original = {"a": 1, "b": 2, "c": 3}
inverted = {v: k for k, v in original.items()}
print(inverted) # {1: 'a', 2: 'b', 3: 'c'}
# When values aren't unique, group keys by value
grades = {"Alice": "A", "Bob": "B", "Charlie": "A", "Dave": "C"}
by_grade = {}
for student, grade in grades.items():
by_grade.setdefault(grade, []).append(student)
print(by_grade) # {'A': ['Alice', 'Charlie'], 'B': ['Bob'], 'C': ['Dave']}
Output
{1: 'a', 2: 'b', 3: 'c'}
{'A': ['Alice', 'Charlie'], 'B': ['Bob'], 'C': ['Dave']}11. View Objects Deep Dive
python example
d = {"a": 1, "b": 2, "c": 3}
k = d.keys()
v = d.values()
i = d.items()
print(type(k)) # <class 'dict_keys'>
print(type(v)) # <class 'dict_values'>
print(type(i)) # <class 'dict_items'>
# Views support set-like operations (keys and items)
d1 = {"a": 1, "b": 2, "c": 3}
d2 = {"b": 20, "c": 30, "d": 40}
# Common keys
common_keys = d1.keys() & d2.keys()
print(common_keys) # {'b', 'c'}
# Keys only in d1
only_d1 = d1.keys() - d2.keys()
print(only_d1) # {'a'}
# Common (key, value) pairs
common_items = d1.items() & d2.items()
print(common_items) # set() (no matching key-value pairs)
# values() does NOT support set operations (values may be unhashable)
# d1.values() & d2.values() → TypeErrorOutput
<class 'dict_keys'>
<class 'dict_values'>
<class 'dict_items'>
{'b', 'c'}
{'a'}
set()12. Method vs Operator Comparison
python example
d1 = {"a": 1, "b": 2}
d2 = {"b": 20, "c": 30}
# Merge (new dict)
m1 = {**d1, **d2} # Python 3.5+ unpacking
m2 = d1 | d2 # Python 3.9+ operator
m3 = dict(d1)
m3.update(d2) # update method
print(m1 == m2) # True
print(m2 == m3) # True
# In-place merge
d1 |= d2 # Python 3.9+ operator
# vs
d1.update(d2) # method (equivalent)Output
True True
13. Interview Questions
Q1: get() और [] access में क्या difference है?
d[key]– key missing होने परKeyErrorraise होता है।d.get(key, default)– key missing होने परNone(या custom default) return करता है, no exception।
Q2: keys(), values(), items() क्या return करते हैं?
ये view objects return करते हैं, static list नहीं। Views live हैं – dict change होने पर automatically reflect होती है। List चाहिए तो list(d.keys()) use करें।Q3: setdefault() का best use case क्या है?
Grouping items या nested structure initialize करने के लिए:
python example
groups = {}
for item in items:
groups.setdefault(item.category, []).append(item)Q4: fromkeys() में mutable default क्यों dangerous है?
Example
# ❌ सभी keys same list object share करते हैं
bad = dict.fromkeys(["a","b","c"], [])
bad["a"].append(1) # सभी change हो जाते हैं!
# ✅ Comprehension use करें
good = {k: [] for k in ["a","b","c"]}
Q5: pop() और popitem() में क्या difference है?
pop(key)– specific key हटाता है, value return करता है।popitem()– last inserted (key, value) pair हटाता है, tuple return करता है।
Summary Cheatsheet
Example
d = {"a": 1, "b": 2, "c": 3}
# Access
d.get("a") # 1
d.get("z", 0) # 0 (default)
# View objects
d.keys() # dict_keys(['a', 'b', 'c'])
d.values() # dict_values([1, 2, 3])
d.items() # dict_items([('a',1), ('b',2), ('c',3)])
# Modify
d.update({"d": 4}) # add/update
d.setdefault("e", 5) # add only if missing
# Remove
d.pop("a") # remove 'a', return 1
d.pop("z", None) # no error if missing
d.popitem() # remove & return last pair
d.clear() # remove all
# Create/Copy
dict.fromkeys(["x","y"], 0) # {'x': 0, 'y': 0}
d.copy() # shallow copy
⚠️ Common Mistakes
Mistake 1: fromkeys() में Mutable Default Use करना ❌
Example
# ❌ WRONG – सभी keys same list share करते हैं
bad = dict.fromkeys(["a", "b", "c"], [])
bad["a"].append(1)
print(bad) # {'a': [1], 'b': [1], 'c': [1]} 😱
Output
{'a': [1], 'b': [1], 'c': [1]}Example
# ✅ RIGHT – dict comprehension use करो
good = {k: [] for k in ["a", "b", "c"]}
good["a"].append(1)
print(good) # {'a': [1], 'b': [], 'c': []}
Output
{'a': [1], 'b': [], 'c': []}Mistake 2: update() का Return Value Use करना ❌
python example
# ❌ WRONG – update() returns None, not the dict!
d = {"a": 1}
result = d.update({"b": 2})
print(result) # None 😵Output
None
python example
# ✅ RIGHT – update() in-place काम करता है
d = {"a": 1}
d.update({"b": 2})
print(d) # {'a': 1, 'b': 2}Output
{'a': 1, 'b': 2}Mistake 3: Loop में Dict Size Change करना ❌
Example
# ❌ WRONG – RuntimeError: dictionary changed size during iteration
d = {"a": 1, "b": 2, "c": 3}
# for key in d:
# if d[key] < 3:
# del d[key] # RuntimeError!
# ✅ RIGHT – list copy बनाकर iterate करो
d = {"a": 1, "b": 2, "c": 3}
for key in list(d.keys()):
if d[key] < 3:
del d[key]
print(d) # {'c': 3}
Output
{'c': 3}Mistake 4: copy() को Deep Copy समझना ❌
Example
# ❌ WRONG – shallow copy nested objects share करता है
original = {"data": [1, 2, 3]}
shallow = original.copy()
shallow["data"].append(4)
print(original["data"]) # [1, 2, 3, 4] 😱 original भी change!
Output
[1, 2, 3, 4]
Example
# ✅ RIGHT – nested objects के लिए deepcopy use करो
import copy
original = {"data": [1, 2, 3]}
deep = copy.deepcopy(original)
deep["data"].append(4)
print(original["data"]) # [1, 2, 3] ✅ safe!
Output
[1, 2, 3]
Mistake 5: pop() बिना Default के Missing Key पर ❌
python example
# ❌ WRONG – KeyError if key doesn't exist
d = {"name": "Alice"}
# val = d.pop("email") # KeyError: 'email'
# ✅ RIGHT – default value provide करो
val = d.pop("email", None)
print(val) # None (no error)Output
None
Mistake 6: clear() और Reassignment में Confuse होना ❌
python example
# ❌ Unexpected behavior – references matter!
a = {"x": 1}
b = a
a = {} # a को new dict assign किया
print(b) # {'x': 1} – b अभी भी old dict point कर रहा है!
# ✅ clear() in-place सभी references affect करता है
a = {"x": 1}
b = a
a.clear()
print(b) # {} – both clearedOutput
{'x': 1}
{}Mistake 7: View Objects को List की तरह Index करना ❌
Example
# ❌ WRONG – views support indexing नहीं करते
d = {"a": 1, "b": 2, "c": 3}
# first_key = d.keys()[0] # TypeError!
# ✅ RIGHT – list() या next(iter()) use करो
first_key = list(d.keys())[0]
# या more efficient:
first_key = next(iter(d))
print(first_key) # 'a'
Output
a
✅ Key Takeaways
- 🔑
get()always prefer करो[]access के बजाय जब key exist करना uncertain हो – KeyError से बचो! - 🔄 View objects live हैं –
keys(),values(),items()dictionary changes automatically reflect करते हैं - 📦
setdefault()= get + insert – key missing हो तो default set करके return करता है, grouping के लिए perfect - ⚡
update()returns None – यह in-place operation है, chain करने के लिए|operator (Python 3.9+) use करो - 🗑️
pop()vspopitem()–pop(key)specific key हटाता है,popitem()last inserted item (LIFO order) - 📋
fromkeys()+ mutable = danger – list/dict default सभी keys share करते हैं, comprehension use करो - 🧬
copy()= shallow only – nested objects के लिएcopy.deepcopy()ज़रूरी है - 🧹
clear()vs= {}–clear()सभी references affect करता है, reassignment नया object बनाता है - 🔗 Set operations on views –
d1.keys() & d2.keys()से common keys मिलते हैं (powerful feature!) - 📊 Time Complexity – ज़्यादातर dict methods O(1) हैं,
update()O(n) जहाँ n = other dict size
❓ FAQ
Q1: get() और setdefault() में क्या difference है?
Answer: get() सिर्फ value return करता है, dictionary modify नहीं करता। setdefault() key missing होने पर default value insert भी करता है dict में और फिर return करता है। अगर आप dict change नहीं चाहते तो get(), अगर missing key पर auto-insert चाहते हो तो setdefault() use करो।
Q2: Dict views को list में convert करने की ज़रूरत कब होती है?
Answer: जब आपको indexing (keys[0]), slicing (keys[:3]), या repeated iteration with modification चाहिए। Views indexing support नहीं करते। हालांकि, simple iteration और in check के लिए views directly use करना ज़्यादा efficient है – extra memory नहीं लगती।
Q3: popitem() किस order में items remove करता है?
Answer: Python 3.7+ में popitem() LIFO (Last-In, First-Out) order follow करता है – last inserted item पहले remove होता है। Python 3.6 से पहले dict unordered था, तो popitem() arbitrary item return करता था। Modern Python में dict insertion order maintain करता है।
Q4: d1 | d2 और d1.update(d2) में क्या difference है?
Answer: d1 | d2 (Python 3.9+) एक new dict return करता है, original dicts unchanged रहते हैं। d1.update(d2) in-place modify करता है d1 को और None return करता है। Functional programming style में | prefer करो, in-place modification चाहिए तो update() use करो।
Q5: Dictionary iterate करते समय items delete कैसे करें?
Answer: Directly iteration में delete करने से RuntimeError आता है। Solution: list(d.keys()) की copy बनाकर iterate करो, या dict comprehension से new filtered dict बनाओ:
python example
# Safe way
d = {k: v for k, v in d.items() if v >= threshold}Q6: copy() कब sufficient है और deepcopy() कब ज़रूरी है?
Answer: अगर dict में सिर्फ immutable values हैं (int, str, tuple) तो copy() काफ़ी है। अगर nested lists, dicts, या custom objects हैं तो deepcopy() use करो – otherwise nested changes original में reflect होंगे।
Q7: क्या dict.fromkeys() efficient है बड़ी keys list के लिए?
Answer: हाँ, dict.fromkeys() internally optimized है और dict comprehension से slightly faster हो सकता है simple immutable defaults (int, str, None) के लिए। But mutable defaults (list, dict) के लिए हमेशा comprehension use करो – fromkeys एक ही object share करता है।
Q8: setdefault() vs defaultdict – कौनसा better है?
Answer: defaultdict (from collections) better है जब हर access पर default चाहिए – automatically handle करता है। setdefault() better है one-off cases में या जब आप regular dict ही रखना चाहते हो। defaultdict slightly faster भी है heavy usage में क्योंकि Python-level method call avoid होता है।
🎯 Interview Questions (Detailed)
Q1: get() और [] access में क्या difference है? Real-world scenario बताओ।
Answer: d[key] key missing होने पर KeyError raise करता है, जबकि d.get(key, default) gracefully None या custom default return करता है। Real-world: API response parse करते समय response.get("data", {}).get("user", None) safe है – nested missing keys पर crash नहीं होता। Production code में almost always get() prefer करो।
Q2: Dictionary view objects क्या हैं? ये list से कैसे different हैं?
Answer: keys(), values(), items() view objects return करते हैं जो:
- Live/Dynamic हैं – dict change होने पर automatically update होते हैं
- Memory efficient – data copy नहीं करते, original dict point करते हैं
- Set operations support करते हैं (keys और items views)
- Indexing support नहीं करते (
views[0]TypeError देगा)
List static snapshot है, view dynamic reference है।
Q3: setdefault() internally कैसे काम करता है? Time complexity क्या है?
Answer: setdefault(key, default) internally: (1) Check if key exists → O(1) hash lookup, (2) If yes, return existing value, (3) If no, insert key: default pair and return default। Overall O(1) average case। यह atomically "check and set" करता है – race conditions avoid होते हैं single-threaded code में।
Q4: Shallow copy और deep copy का difference code से explain करो।
Answer:
Example
import copy
original = {"list": [1, 2, 3], "nested": {"x": 10}}
shallow = original.copy() # Top-level copy only
deep = copy.deepcopy(original) # Recursive full copy
shallow["list"].append(4)
print(original["list"]) # [1, 2, 3, 4] – shared reference!
deep["nested"]["x"] = 99
print(original["nested"]["x"]) # 10 – independent copy
Output
[1, 2, 3, 4] 10
Shallow copy सिर्फ top-level keys copy करता है, nested objects same reference share करते हैं। Deep copy recursively सब copy करता है।
Q5: Dict merge करने के कितने तरीके हैं Python में? Performance compare करो।
Answer:
python example
d1, d2 = {"a": 1}, {"b": 2}
# Method 1: update() – in-place, O(n)
d1.update(d2)
# Method 2: | operator (Python 3.9+) – new dict, O(n+m)
merged = d1 | d2
# Method 3: unpacking (Python 3.5+) – new dict, O(n+m)
merged = {**d1, **d2}
# Method 4: dict() constructor
merged = dict(d1, **d2) # ⚠️ keys must be stringsPerformance: update() fastest for in-place, | और {**} similar for new dict creation। Large dicts के लिए in-place update() memory efficient है।
Q6: popitem() का LIFO behavior कब useful है?
Answer: Stack-like processing में: जब items insert order में process करने हों (last first)। Example: Undo operations, task queue (LIFO), या temporary storage drain करना। Python 3.7+ guarantee करता है insertion order, इसलिए popitem() reliably last item देता है।
Q7: Dictionary iteration के दौरान size change करने पर क्या होता है?
Answer: RuntimeError: dictionary changed size during iteration raise होता है। Solutions:
Example
# Solution 1: keys की copy iterate करो
for key in list(d.keys()):
if condition:
del d[key]
# Solution 2: new dict बनाओ (comprehension)
d = {k: v for k, v in d.items() if not condition}
Python deliberately यह error raise करता है undefined behavior prevent करने के लिए।
Q8: dict.fromkeys() vs dict comprehension – कब कौनसा use करें?
Answer: fromkeys() use करो जब सभी keys को same immutable value assign करना हो (0, None, "default")। Dict comprehension use करो जब: (1) Mutable defaults चाहिए (list, dict), (2) Different values per key चाहिए, (3) Transformation logic apply करनी हो। fromkeys() slightly faster है simple cases में but comprehension ज़्यादा flexible है।
Q9: clear() method कब use करें vs new empty dict assign करना?
Answer: clear() use करो जब multiple references same dict point कर रहे हों और सभी को empty दिखाना हो। d = {} सिर्फ variable rebind करता है, दूसरे references पर कोई effect नहीं। Memory perspective: clear() internal hash table release करता है, reassignment old dict garbage collect होने पर memory free करता है।
Q10: Real interview problem – Two dicts merge करो with custom conflict resolution
Answer:
Example
def merge_with_strategy(d1, d2, strategy="last_wins"):
"""Merge two dicts with conflict resolution"""
result = d1.copy()
for key, val in d2.items():
if key in result:
if strategy == "last_wins":
result[key] = val
elif strategy == "first_wins":
pass # keep d1's value
elif strategy == "sum":
result[key] = result[key] + val
elif strategy == "list":
result[key] = [result[key], val]
else:
result[key] = val
return result
# Test
a = {"x": 1, "y": 2, "z": 3}
b = {"y": 20, "z": 30, "w": 40}
print(merge_with_strategy(a, b, "sum"))
# {'x': 1, 'y': 22, 'z': 33, 'w': 40}
print(merge_with_strategy(a, b, "list"))
# {'x': 1, 'y': [2, 20], 'z': [3, 30], 'w': 40}
Output
{'x': 1, 'y': 22, 'z': 33, 'w': 40}
{'x': 1, 'y': [2, 20], 'z': [3, 30], 'w': 40}यह pattern real-world config merging, data aggregation में काम आता है।
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Python Dictionary Methods – Complete Reference.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Python Master Course topic.
Search Terms
python-master-course, python master course, python, master, course, data, structures, dictionary
Related Python Master Course Topics
Continue learning this concept
Data StructuresPython List Methods – All Built-in MethodsPython List के सभी built-in methods का complete reference – append, extend, insert, remove, pop, sort, reverse, index, count, copy, clear – examples और time complexity के साथ।Data StructuresPython Set Methods – Complete ReferencePython Set के सभी built-in methods का complete reference – add, remove, discard, pop, clear, update, union, intersection, difference, symmetric_difference और in-place variants के साथ examples।Data StructuresPython Comprehensions – List, Dict, Set & GeneratorPython Comprehensions का complete guide – list comprehension, dictionary comprehension, set comprehension, generator expressions, nested comprehensions, conditional filtering, और performance comparison with Hindi explanations।Data StructuresPython Dictionaries – Key-Value StorePython Dictionaries का complete guide – creation, access, modification, nested dicts, dict comprehension, defaultdict, OrderedDict, और real-world use cases with Hindi explanations और interview questions।Data StructuresPython Lists – Complete GuidePython Lists ka complete guide – creation, indexing, slicing, mutability, nesting, and real-world usage with code examples, time complexity, and interview questions.Data StructuresPython Sets – Unordered Unique CollectionsPython Sets का complete guide – creation, operations, set theory (union, intersection, difference), frozen sets, और real-world use cases with Hindi explanations और interview questions.