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 Dictionaries का complete guide – creation, access, modification, nested dicts, dict comprehension, defaultdict, OrderedDict, और real-world use cases with Hindi explanations और interview questions।
Introduction (परिचय)
Dictionary एक key-value pair collection है। यह Python का सबसे powerful built-in data structure है।
Key Properties: - ✅ Key-Value pairs – हर element key: value के रूप में - ✅ Ordered – Python 3.7+ में insertion order maintain होता है - ✅ Mutable – Add/modify/delete किया जा सकता है - ❌ Duplicate Keys – Keys unique होनी चाहिए (overwrite होती है) - ✅ Keys must be hashable – string, int, tuple (not list/dict) - ⚡ O(1) average lookup by key2. Accessing Values (Values तक पहुँचना)
Example
student = {"name": "Rahul", "age": 20, "grade": "A", "score": 95}
# Direct access with [] (KeyError if not found)
print(student["name"]) # Rahul
print(student["score"]) # 95
# KeyError demonstration
try:
print(student["phone"])
except KeyError as e:
print(f"KeyError: {e}") # KeyError: 'phone'
# get() – safe access (returns None or default if not found)
print(student.get("name")) # Rahul
print(student.get("phone")) # None (no error!)
print(student.get("phone", "N/A")) # N/A (custom default)
print(student.get("age", 0)) # 20 (key exists, default ignored)
# Nested access
school = {"student": {"name": "Alice", "marks": {"math": 90, "science": 85}}}
print(school["student"]["marks"]["math"]) # 90
# Safe nested access with get()
math_marks = school.get("student", {}).get("marks", {}).get("math", 0)
print(math_marks) # 90
# Check key existence
print("name" in student) # True
print("email" in student) # False
print("email" not in student) # True
Output:
Example
Rahul
95
KeyError: 'phone'
Rahul
None
N/A
20
90
90
True
False
True
3. Adding and Updating
Example
profile = {"name": "Alice", "age": 25}
# Add new key-value pair
profile["email"] = "alice@email.com"
print(profile) # {'name': 'Alice', 'age': 25, 'email': 'alice@email.com'}
# Update existing key
profile["age"] = 26
print(profile["age"]) # 26
# update() – multiple updates at once
profile.update({"city": "Delhi", "phone": "9876543210"})
print(profile)
# update() with keyword arguments
profile.update(age=27, email="new@email.com")
print(profile["age"]) # 27
# setdefault() – add only if key doesn't exist
profile.setdefault("country", "India") # Added
profile.setdefault("name", "Unknown") # NOT changed (key exists)
print(profile.get("country")) # India
print(profile.get("name")) # Alice (unchanged)
# Merge dicts (Python 3.9+)
d1 = {"a": 1, "b": 2}
d2 = {"b": 20, "c": 30}
merged = d1 | d2 # new dict, d2 values win on conflicts
print(merged) # {'a': 1, 'b': 20, 'c': 30}
d1 |= d2 # in-place merge
print(d1) # {'a': 1, 'b': 20, 'c': 30}
# Older way (Python 3.5+)
merged2 = {**d1, **d2}
print(merged2)
4. Deleting Elements
Example
data = {"a": 1, "b": 2, "c": 3, "d": 4, "e": 5}
# del – delete by key (KeyError if missing)
del data["a"]
print(data) # {'b': 2, 'c': 3, 'd': 4, 'e': 5}
try:
del data["z"]
except KeyError as e:
print(f"KeyError: {e}")
# pop() – delete and return value
val = data.pop("b")
print(f"Popped: {val}") # Popped: 2
print(data) # {'c': 3, 'd': 4, 'e': 5}
# pop() with default (no error if missing)
val = data.pop("z", "not found")
print(val) # not found
# popitem() – remove and return last inserted (key, value) pair
last = data.popitem()
print(f"Popped item: {last}") # ('e', 5)
print(data) # {'c': 3, 'd': 4}
# clear() – remove all
data.clear()
print(data) # {}
5. Dictionary Iteration (Traversal)
Example
inventory = {"apple": 50, "banana": 30, "cherry": 20, "date": 15}
# Iterate over keys (default)
for key in inventory:
print(key, end=" ")
print() # apple banana cherry date
# Iterate over values
for val in inventory.values():
print(val, end=" ")
print() # 50 30 20 15
# Iterate over key-value pairs
for key, val in inventory.items():
print(f"{key}: {val}")
# keys(), values(), items() return view objects
keys = inventory.keys()
vals = inventory.values()
items = inventory.items()
print(type(keys)) # <class 'dict_keys'>
# Views are dynamic (reflect changes)
inventory["elderberry"] = 10
print(list(keys)) # includes 'elderberry'!
# Sorted iteration
for key in sorted(inventory):
print(f"{key}: {inventory[key]}")
# Sorted by value
for key in sorted(inventory, key=inventory.get):
print(f"{key}: {inventory[key]}")
# Sorted by value (descending)
for key, val in sorted(inventory.items(), key=lambda x: x[1], reverse=True):
print(f"{key}: {val}")
6. Nested Dictionaries
Example
# Company employee database
company = {
"engineering": {
"Alice": {"age": 28, "salary": 80000, "skills": ["Python", "ML"]},
"Bob": {"age": 25, "salary": 65000, "skills": ["Java", "Spring"]}
},
"marketing": {
"Charlie": {"age": 30, "salary": 70000, "skills": ["SEO", "Analytics"]},
"Dave": {"age": 27, "salary": 60000, "skills": ["Social Media"]}
}
}
# Access deeply nested
print(company["engineering"]["Alice"]["salary"]) # 80000
print(company["marketing"]["Dave"]["skills"][0]) # Social Media
# Update nested
company["engineering"]["Alice"]["salary"] = 90000
company["engineering"]["Alice"]["skills"].append("Deep Learning")
# Add new department
company["sales"] = {
"Eve": {"age": 26, "salary": 55000, "skills": ["Negotiation"]}
}
# Traverse nested dict
for dept, employees in company.items():
print(f"\n{dept.upper()}:")
for emp, details in employees.items():
print(f" {emp}: ₹{details['salary']:,}")
# Flatten nested dict
def flatten_dict(d, parent_key='', sep='.'):
items = {}
for k, v in d.items():
new_key = f"{parent_key}{sep}{k}" if parent_key else k
if isinstance(v, dict):
items.update(flatten_dict(v, new_key, sep))
else:
items[new_key] = v
return items
simple = {"a": {"b": {"c": 1, "d": 2}, "e": 3}, "f": 4}
flat = flatten_dict(simple)
print(flat)
# {'a.b.c': 1, 'a.b.d': 2, 'a.e': 3, 'f': 4}
7. Dictionary Comprehension
Example
# Basic: {key_expr: value_expr for item in iterable}
# Squares dict
squares = {x: x**2 for x in range(1, 6)}
print(squares) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# With condition
even_squares = {x: x**2 for x in range(1, 11) if x % 2 == 0}
print(even_squares) # {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}
# Invert a dictionary (swap keys and values)
original = {"a": 1, "b": 2, "c": 3}
inverted = {v: k for k, v in original.items()}
print(inverted) # {1: 'a', 2: 'b', 3: 'c'}
# Filter dict by value
scores = {"Alice": 85, "Bob": 72, "Charlie": 91, "Dave": 68}
passed = {k: v for k, v in scores.items() if v >= 75}
print(passed) # {'Alice': 85, 'Charlie': 91}
# Transform values
prices = {"apple": 100, "banana": 50, "cherry": 200}
discounted = {k: v * 0.9 for k, v in prices.items()}
print(discounted) # {'apple': 90.0, 'banana': 45.0, 'cherry': 180.0}
# From two lists
keys = ["name", "age", "city"]
vals = ["Alice", 25, "Delhi"]
profile = {k: v for k, v in zip(keys, vals)}
print(profile) # {'name': 'Alice', 'age': 25, 'city': 'Delhi'}
# Word frequency
words = "the quick brown fox jumps over the lazy dog the".split()
freq = {word: words.count(word) for word in set(words)}
print(freq)
8. Special Dict Types (collections module)
Example
from collections import defaultdict, OrderedDict, Counter
# ── defaultdict ──────────────────────────────────────────
# Missing key पर automatically default value create होती है
# Group items by category
dd = defaultdict(list)
items = [("fruit", "apple"), ("veggie", "carrot"), ("fruit", "banana"), ("veggie", "pea")]
for category, item in items:
dd[category].append(item)
print(dict(dd)) # {'fruit': ['apple', 'banana'], 'veggie': ['carrot', 'pea']}
# Count without KeyError
word_count = defaultdict(int)
for word in "hello world hello python world hello".split():
word_count[word] += 1
print(dict(word_count)) # {'hello': 3, 'world': 2, 'python': 1}
# ── Counter ──────────────────────────────────────────────
# Counting के लिए specialized dict
text = "mississippi"
c = Counter(text)
print(c) # Counter({'s': 4, 'i': 4, 'p': 2, 'm': 1})
print(c.most_common(3)) # [('s', 4), ('i', 4), ('p', 2)]
print(c['s']) # 4
print(c['z']) # 0 (no KeyError!)
# Counter arithmetic
c1 = Counter("aab")
c2 = Counter("abc")
print(c1 + c2) # Counter({'a': 3, 'b': 2, 'c': 1})
print(c1 - c2) # Counter({'a': 1})
print(c1 & c2) # Counter({'a': 1, 'b': 1}) (intersection)
print(c1 | c2) # Counter({'a': 2, 'b': 1, 'c': 1}) (union)
# ── OrderedDict ──────────────────────────────────────────
# Python 3.7+ में regular dict भी ordered है,
# लेकिन OrderedDict में extra reordering methods हैं
od = OrderedDict([("first", 1), ("second", 2), ("third", 3)])
od.move_to_end("first") # move to end
print(list(od.keys())) # ['second', 'third', 'first']
od.move_to_end("first", last=False) # move to beginning
print(list(od.keys())) # ['first', 'second', 'third']
9. Time Complexity
| Operation | Average | Worst | Notes |
|---|---|---|---|
d[key] (get) | O(1) | O(n) | Hash collision |
d[key] = v (set) | O(1) | O(n) | Hash collision |
del d[key] | O(1) | O(n) | |
key in d | O(1) | O(n) | |
d.get(key) | O(1) | O(n) | |
len(d) | O(1) | O(1) | |
| Iteration | O(n) | O(n) | |
d.copy() | O(n) | O(n) | |
d.update(e) | O(k) | O(k) | k = len(e) |
💡 Worst case O(n) तब होता है जब बहुत सारे hash collisions हों (extremely rare with Python's hash implementation)।
10. Real-World Examples
Example
# 1. Configuration/Settings
config = {
"debug": True,
"database": {
"host": "localhost",
"port": 5432,
"name": "mydb"
},
"cache_ttl": 3600
}
db_host = config.get("database", {}).get("host", "localhost")
print(f"DB Host: {db_host}")
# 2. Frequency counter
def word_frequency(text):
words = text.lower().split()
freq = {}
for word in words:
freq[word] = freq.get(word, 0) + 1
return sorted(freq.items(), key=lambda x: x[1], reverse=True)
text = "python is great python is fun python"
print(word_frequency(text))
# [('python', 3), ('is', 2), ('great', 1), ('fun', 1)]
# 3. Cache / Memoization
memo = {}
def fibonacci(n):
if n in memo:
return memo[n]
if n <= 1:
return n
result = fibonacci(n-1) + fibonacci(n-2)
memo[n] = result
return result
print([fibonacci(i) for i in range(10)])
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
# 4. Graph as adjacency list
graph = {
"A": ["B", "C"],
"B": ["A", "D"],
"C": ["A", "D"],
"D": ["B", "C"]
}
# BFS
def bfs(graph, start):
visited = []
queue = [start]
seen = {start}
while queue:
node = queue.pop(0)
visited.append(node)
for neighbor in graph[node]:
if neighbor not in seen:
seen.add(neighbor)
queue.append(neighbor)
return visited
print(bfs(graph, "A")) # ['A', 'B', 'C', 'D']
11. Interview Questions
Q1: Dictionary में duplicate key add करने पर क्या होता है?
Example
d = {"a": 1, "a": 2, "a": 3}
print(d) # {'a': 3} ← last value wins
d["a"] = 4 # overwrite
print(d) # {'a': 4}
Q2: Dict को value से sort कैसे करें?
Example
scores = {"Alice": 85, "Bob": 92, "Charlie": 78}
# Sort by value (ascending)
sorted_scores = dict(sorted(scores.items(), key=lambda x: x[1]))
print(sorted_scores) # {'Charlie': 78, 'Alice': 85, 'Bob': 92}
# Descending
sorted_desc = dict(sorted(scores.items(), key=lambda x: x[1], reverse=True))
Q3: Two dicts को merge कैसे करें?
python example
a = {"x": 1, "y": 2}
b = {"y": 20, "z": 30}
# Python 3.9+
merged = a | b # {'x': 1, 'y': 20, 'z': 30}
# Python 3.5+
merged = {**a, **b} # same
# update()
a.update(b) # in-placeQ4: Dictionary में सबसे common key कैसे ढूँढें?
Example
words = ["apple", "banana", "apple", "cherry", "apple", "banana"]
from collections import Counter
most_common = Counter(words).most_common(1)[0][0]
print(most_common) # apple
Q5: Dict keys को list में convert?
Example
d = {"a": 1, "b": 2, "c": 3}
keys = list(d.keys()) # ['a', 'b', 'c']
vals = list(d.values()) # [1, 2, 3]
items = list(d.items()) # [('a', 1), ('b', 2), ('c', 3)]
Summary
| Feature | Detail |
|---|---|
| Syntax | {key: val, ...} |
| Keys | Unique, hashable |
| Values | Any type |
| Ordered | Python 3.7+ (insertion order) |
| Access | d[key] or d.get(key) |
| Complexity | O(1) average for get/set/delete |
| Special | defaultdict, Counter, OrderedDict |
| Comprehension | {k: v for k, v in iterable} |
🎯 Use Dict when: आपको fast key-based lookup चाहिए – phone book, config, cache, frequency counting।
📤 Output Blocks (Missing Sections)
Section 3 – Adding and Updating Output:
Output
{'name': 'Alice', 'age': 25, 'email': 'alice@email.com'}
26
{'name': 'Alice', 'age': 26, 'email': 'alice@email.com', 'city': 'Delhi', 'phone': '9876543210'}
27
India
Alice
{'a': 1, 'b': 20, 'c': 30}
{'a': 1, 'b': 20, 'c': 30}
{'a': 1, 'b': 20, 'c': 30}Section 4 – Deleting Elements Output:
Output
{'b': 2, 'c': 3, 'd': 4, 'e': 5}
KeyError: 'z'
Popped: 2
{'c': 3, 'd': 4, 'e': 5}
not found
Popped item: ('e', 5)
{'c': 3, 'd': 4}
{}Section 5 – Dictionary Iteration Output:
Output
apple banana cherry date 50 30 20 15 apple: 50 banana: 30 cherry: 20 date: 15 <class 'dict_keys'> ['apple', 'banana', 'cherry', 'date', 'elderberry'] apple: 50 banana: 30 cherry: 20 date: 15 elderberry: 10 elderberry: 10 date: 15 cherry: 20 banana: 30 apple: 50 apple: 50 banana: 30 cherry: 20 date: 15 elderberry: 10
Section 6 – Nested Dictionaries Output:
Output
80000
Social Media
ENGINEERING:
Alice: ₹90,000
Bob: ₹65,000
MARKETING:
Charlie: ₹70,000
Dave: ₹60,000
SALES:
Eve: ₹55,000
{'a.b.c': 1, 'a.b.d': 2, 'a.e': 3, 'f': 4}Section 7 – Dictionary Comprehension Output:
Output
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
{2: 4, 4: 16, 6: 36, 8: 64, 10: 100}
{1: 'a', 2: 'b', 3: 'c'}
{'Alice': 85, 'Charlie': 91}
{'apple': 90.0, 'banana': 45.0, 'cherry': 180.0}
{'name': 'Alice', 'age': 25, 'city': 'Delhi'}
{'the': 3, 'quick': 1, 'brown': 1, 'fox': 1, 'jumps': 1, 'over': 1, 'lazy': 1, 'dog': 1}Section 8 – Special Dict Types Output:
Output
{'fruit': ['apple', 'banana'], 'veggie': ['carrot', 'pea']}
{'hello': 3, 'world': 2, 'python': 1}
Counter({'s': 4, 'i': 4, 'p': 2, 'm': 1})
[('s', 4), ('i', 4), ('p', 2)]
4
0
Counter({'a': 3, 'b': 2, 'c': 1})
Counter({'a': 1})
Counter({'a': 1, 'b': 1})
Counter({'a': 2, 'b': 1, 'c': 1})
['second', 'third', 'first']
['first', 'second', 'third']Section 10 – Real-World Examples Output:
Output
DB Host: localhost
[('python', 3), ('is', 2), ('great', 1), ('fun', 1)]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
['A', 'B', 'C', 'D']Section 11 – Interview Questions Output:
Output
{'a': 3}
{'a': 4}
{'Charlie': 78, 'Alice': 85, 'Bob': 92}
apple⚠️ Common Mistakes
1. ❌ Mutable key use करना (List as key)
Example
# Wrong ❌
d = {[1, 2]: "value"} # TypeError: unhashable type: 'list'
# Right ✅
d = {(1, 2): "value"} # Tuple is hashable
💡 Dict keys hashable होनी चाहिए – string, int, tuple OK हैं, list/dict/set नहीं!
2. ❌ KeyError handle नहीं करना
Example
# Wrong ❌
data = {"name": "Alice"}
print(data["age"]) # KeyError: 'age' 💥
# Right ✅
print(data.get("age", "N/A")) # N/A (safe!)
💡 हमेशा.get()use करो याinसे check करो key access करने से पहले।
3. ❌ Iteration के दौरान dict modify करना
Example
# Wrong ❌
scores = {"a": 1, "b": 2, "c": 3}
for key in scores:
if scores[key] < 2:
del scores[key] # RuntimeError: dictionary changed size during iteration
# Right ✅
scores = {k: v for k, v in scores.items() if v >= 2}
# OR
for key in list(scores.keys()): # iterate over a copy
if scores[key] < 2:
del scores[key]
💡 Iteration में dict size change करना allowed नहीं – copy बनाओ या comprehension use करो।
4. ❌ == vs is confusion with dicts
python example
a = {"x": 1}
b = {"x": 1}
print(a == b) # True (same content)
print(a is b) # False (different objects!)💡==content compare करता है,isidentity (memory location) check करता है।
5. ❌ Shallow copy में nested changes reflect होना
Example
# Wrong expectation ❌
original = {"name": "Alice", "marks": [90, 85]}
copy_dict = original.copy() # SHALLOW copy
copy_dict["marks"].append(95)
print(original["marks"]) # [90, 85, 95] 😱 original भी change हो गया!
# Right ✅
import copy
deep = copy.deepcopy(original)
deep["marks"].append(100)
print(original["marks"]) # [90, 85, 95] ← unchanged
💡 Nested objects के लिएcopy.deepcopy()use करो,.copy()shallow है!
6. ❌ fromkeys() के साथ mutable default value
Example
# Wrong ❌
d = dict.fromkeys(["a", "b", "c"], [])
d["a"].append(1)
print(d) # {'a': [1], 'b': [1], 'c': [1]} 😱 सब share करते हैं same list!
# Right ✅
d = {key: [] for key in ["a", "b", "c"]}
d["a"].append(1)
print(d) # {'a': [1], 'b': [], 'c': []} ✅
💡 fromkeys() same object reference share करता है – mutable default मत दो!7. ❌ Dict ordering assume करना (Python < 3.7)
Example
# Python 3.6 and below में dict ordering guaranteed नहीं है
# Python 3.7+ में insertion order maintain होता है
# लेकिन अगर code backward compatible रखना है तो OrderedDict use करो
from collections import OrderedDict
od = OrderedDict([("first", 1), ("second", 2)])
💡 Python 3.7+ में dict ordered है, पर explicit ordering चाहिए तो OrderedDict safe option है।✅ Key Takeaways
- 🔑 Dictionary एक key-value pair collection है – fast lookup (O(1) average) के लिए best choice।
- 🔐 Keys unique और hashable होनी चाहिए – string, int, tuple OK; list, dict, set ❌।
- 🛡️
d.get(key, default)use करो – KeyError से बचने का safest तरीका। - 📦
defaultdictuse करो जब missing keys पर automatic default value चाहिए (grouping/counting)। - 🔢
Counteruse करो frequency counting के लिए –.most_common()बहुत handy है। - 🔄 Dict comprehension
{k: v for k, v in iterable}– filtering और transformation के लिए elegant। - ⚡ Python 3.9+ में
d1 | d2merge operator use करो – clean और readable। - 📋 Nested dicts को access करते time
.get()chain करो – safe nested access। - 🧠
copy.deepcopy()use करो nested dicts copy करने के लिए – shallow copy pitfall से बचो। - 🎯 Real-world use cases: config files, caching/memoization, graphs, frequency counting, JSON-like data।
❓ FAQ
Q1: Dict और List में क्या difference है?
Answer: List index-based ordered collection है (0, 1, 2...), जबकि Dict key-based collection है। Dict में access O(1) है by key, List में O(n) search करना पड़ता है। जब आपको named access चाहिए (जैसे student["name"]), तो Dict use करो। Sequential data के लिए List best है।
Q2: Dictionary keys में कौन-कौन से types use कर सकते हैं?
Answer: कोई भी hashable (immutable) type – str, int, float, bool, tuple (अगर tuple के अंदर सब immutable हों)। list, dict, set use नहीं कर सकते क्योंकि ये mutable हैं और hash नहीं हो सकते।
Q3: dict.get() और dict[key] में क्या difference है?
Answer: dict[key] missing key पर KeyError raise करता है। dict.get(key, default) missing key पर None (या custom default) return करता है – कोई error नहीं। Production code में .get() prefer करो।
Q4: defaultdict कब use करना चाहिए?
Answer: जब आपको missing keys पर automatic default value चाहिए – जैसे grouping (defaultdict(list)), counting (defaultdict(int)), या nested dicts (defaultdict(dict))। ये regular dict + manual if key not in d check से cleaner है।
Q5: Dict को value से sort कैसे करें?
Answer:
Example
scores = {"Alice": 85, "Bob": 92, "Charlie": 78}
sorted_dict = dict(sorted(scores.items(), key=lambda x: x[1], reverse=True))
# {'Bob': 92, 'Alice': 85, 'Charlie': 78}
sorted() with key=lambda x: x[1] value पर sort करता है। reverse=True descending order देता है।
Q6: क्या Dictionary thread-safe है Python में?
Answer: Individual operations (get/set/delete) GIL की वजह से atomic हैं, लेकिन compound operations (check-then-update) thread-safe नहीं हैं। Multi-threaded code में threading.Lock use करो या queue.Queue consider करो।
Q7: update() और |= operator में क्या difference है?
Answer: दोनों in-place merge करते हैं। |= Python 3.9+ में available है और ज्यादा readable है। update() सभी Python 3.x versions में काम करता है। Functionality same है – conflicting keys में दूसरे dict की value win करती है।
Q8: Dict comprehension कब use करना चाहिए?
Answer: जब एक existing iterable से dictionary बनानी हो with filtering/transformation। Simple cases में comprehension ज्यादा readable है loops से। लेकिन complex logic हो तो regular loop better है readability के लिए।
🎯 Interview Questions (Advanced)
Q1: __hash__() और __eq__() का dict में क्या role है?
Answer: Dict internally hash table use करता है। जब key insert/lookup होती है, पहले __hash__() call होता है bucket find करने के लिए, फिर __eq__() exact match verify करने के लिए। Custom objects को dict key बनाने के लिए दोनों implement करने होते हैं, और rule है: a == b implies hash(a) == hash(b)।
Q2: Dict internally कैसे implement होता है Python में?
Answer: CPython में dict एक open-addressing hash table है (Python 3.6+ compact dict)। Keys का hash compute होता है, उससे index determine होता है एक internal array में। Collision resolution probing (linear/quadratic) से होता है। Python 3.6+ में एक separate insertion-order array maintain होता है जो ordering guarantee देता है।
Q3: setdefault() vs defaultdict – कब क्या use करें?
Answer:
Example
# setdefault – one-off cases
d = {}
d.setdefault("fruits", []).append("apple")
# defaultdict – repeated pattern
from collections import defaultdict
d = defaultdict(list)
d["fruits"].append("apple")
setdefault() single key के लिए convenient है। defaultdict जब हर missing key पर same pattern चाहिए तो better है – code cleaner और faster होता है।
Q4: Dict का memory usage कैसे optimize करें?
Answer: (1) __slots__ use करो classes में dict eliminate करने के लिए, (2) large dicts के लिए consider sqlite3 या memory-mapped files, (3) sys.getsizeof() से monitor करो, (4) Python 3.6+ compact dict already ~25% less memory use करता है पुराने implementation से।
Q5: Dict view objects (keys/values/items) क्या हैं?
Answer: ये dynamic views हैं – dict change होने पर automatically reflect करते हैं। ये memory efficient हैं (copy नहीं बनाते)। Set operations support करते हैं (intersection, union) keys() और items() views पर। Iteration के दौरान dict modify करना unsafe है।
Example
d = {"a": 1, "b": 2}
keys = d.keys()
d["c"] = 3
print(list(keys)) # ['a', 'b', 'c'] – view reflects changes!
Q6: Two dicts के common और uncommon keys efficiently कैसे find करें?
Answer:
python example
d1 = {"a": 1, "b": 2, "c": 3}
d2 = {"b": 20, "c": 30, "d": 40}
common = d1.keys() & d2.keys() # {'b', 'c'}
only_d1 = d1.keys() - d2.keys() # {'a'}
only_d2 = d2.keys() - d1.keys() # {'d'}
all_keys = d1.keys() | d2.keys() # {'a', 'b', 'c', 'd'}Dict keys views set operations support करते हैं – O(min(n,m)) time complexity।
Q7: ChainMap क्या है और कब useful है?
Answer:
Example
from collections import ChainMap
defaults = {"color": "red", "size": "medium"}
user_prefs = {"color": "blue"}
config = ChainMap(user_prefs, defaults)
print(config["color"]) # blue (user_prefs wins)
print(config["size"]) # medium (falls through to defaults)
ChainMap multiple dicts को logical एक dict जैसा treat करता है – first match wins। Configuration layering, scope resolution (like variable lookup in nested scopes) में useful है। Original dicts modify नहीं होते।
Q8: Dict vs namedtuple vs dataclass – कब कौन use करें?
Answer: Dict – dynamic keys, JSON-like data, unknown structure। namedtuple – lightweight immutable records, memory efficient, tuple compatibility। dataclass – structured data with methods, type hints, mutable by default। Rule: अगर fields fixed हैं और type safety चाहिए तो dataclass; immutable lightweight record चाहिए तो namedtuple; dynamic/flexible structure है तो dict।
Q9: Dict में memory leak कैसे हो सकता है?
Answer: (1) Circular references in nested dicts (GC handles but slowly), (2) Dict as cache without size limit – unbounded growth, (3) Holding references to large objects as values। Solution: weakref.WeakValueDictionary use करो, या functools.lru_cache(maxsize=N) caching के लिए, या manual cleanup implement करो।
Q10: | merge operator (Python 3.9+) internally कैसे काम करता है?
Answer: d1 | d2 internally __or__ method call करता है जो: (1) new dict create करता है, (2) d1 के सभी items copy करता है, (3) d2 के items add/overwrite करता है। Time complexity O(n+m) है। |= (in-place) __ior__ call करता है जो existing dict में d2 merge करता है (same as update() internally)।
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Python Dictionaries – Key-Value Store.
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, dictionaries
Related Python Master Course Topics
Continue learning this concept
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 Dictionary Methods – Complete ReferencePython Dictionary के सभी built-in methods का complete reference – get, keys, values, items, update, pop, popitem, setdefault, copy, clear, fromkeys – examples और time complexity के साथ।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 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 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 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.