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 Lists ka complete guide – creation, indexing, slicing, mutability, nesting, and real-world usage with code examples, time complexity, and interview questions.
Introduction (परिचय)
Python List एक ordered, mutable collection है जो किसी भी type के elements store कर सकती है। यह Python की सबसे versatile और commonly used data structure है।
Key Points: - ✅ Ordered – Elements का order maintain होता है - ✅ Mutable – Creation के बाद modify किया जा सकता है - ✅ Allows Duplicates – Same value multiple times हो सकती है - ✅ Heterogeneous – Different types के elements एक list में - ✅ Dynamic Size – Runtime पर grow/shrink होती है
2. Indexing (इंडेक्सिंग)
Python lists 0-based indexing use करती हैं। Negative indexing भी supported है।
Example
fruits = ["apple", "banana", "cherry", "date", "elderberry"]
# Positive indexing
print(fruits[0]) # apple (पहला element)
print(fruits[1]) # banana
print(fruits[4]) # elderberry (आखिरी element)
# Negative indexing (पीछे से)
print(fruits[-1]) # elderberry (आखिरी)
print(fruits[-2]) # date
print(fruits[-5]) # apple (पहला, negative से)
# Nested list indexing
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(matrix[0][0]) # 1
print(matrix[1][2]) # 6
print(matrix[2][1]) # 8
Output:
Example
apple
banana
elderberry
elderberry
date
apple
1
6
8
Indexing Diagram
Index: 0 1 2 3 4
┌───────┬────────┬───────┬──────┬───────────┐
│ apple │ banana │cherry │ date │elderberry │
└───────┴────────┴───────┴──────┴───────────┘
Index: -5 -4 -3 -2 -1
3. Slicing (स्लाइसिंग)
Slicing syntax: list[start:stop:step]
Example
nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Basic slicing
print(nums[2:6]) # [2, 3, 4, 5] (index 2 से 5 तक)
print(nums[:4]) # [0, 1, 2, 3] (शुरू से index 3 तक)
print(nums[6:]) # [6, 7, 8, 9] (index 6 से अंत तक)
print(nums[:]) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] (पूरी list)
# Step slicing
print(nums[::2]) # [0, 2, 4, 6, 8] (हर दूसरा element)
print(nums[1::2]) # [1, 3, 5, 7, 9] (odd index elements)
print(nums[::3]) # [0, 3, 6, 9]
# Reverse list using slicing
print(nums[::-1]) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
print(nums[7:2:-1]) # [7, 6, 5, 4, 3]
# Negative step
print(nums[8:2:-2]) # [8, 6, 4]
Output:
Example
[2, 3, 4, 5]
[0, 1, 2, 3]
[6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 2, 4, 6, 8]
[1, 3, 5, 7, 9]
[0, 3, 6, 9]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
[7, 6, 5, 4, 3]
[8, 6, 4]
4. List Mutability (बदलाव करना)
Lists mutable होती हैं – elements को change किया जा सकता है।
Example
colors = ["red", "green", "blue"]
# Single element change
colors[1] = "yellow"
print(colors) # ['red', 'yellow', 'blue']
# Slice assignment
colors[0:2] = ["orange", "purple", "pink"]
print(colors) # ['orange', 'purple', 'pink', 'blue']
# Delete elements
del colors[0]
print(colors) # ['purple', 'pink', 'blue']
# Replace slice with fewer/more elements
nums = [1, 2, 3, 4, 5]
nums[1:4] = [20, 30]
print(nums) # [1, 20, 30, 5]
# Insert without removing (empty slice)
nums[2:2] = [99, 100]
print(nums) # [1, 20, 99, 100, 30, 5]
Output:
Example
['red', 'yellow', 'blue']
['orange', 'purple', 'pink', 'blue']
['purple', 'pink', 'blue']
[1, 20, 30, 5]
[1, 20, 99, 100, 30, 5]
5. List Operations (ऑपरेशन)
Example
a = [1, 2, 3]
b = [4, 5, 6]
# Concatenation (+)
c = a + b
print(c) # [1, 2, 3, 4, 5, 6]
# Repetition (*)
d = a * 3
print(d) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
# Membership (in / not in)
print(2 in a) # True
print(7 in a) # False
print(7 not in a) # True
# Length
print(len(c)) # 6
# Min / Max / Sum
nums = [3, 1, 4, 1, 5, 9, 2, 6]
print(min(nums)) # 1
print(max(nums)) # 9
print(sum(nums)) # 31
# Comparison
print([1, 2, 3] == [1, 2, 3]) # True
print([1, 2, 3] < [1, 2, 4]) # True (lexicographic)
print([1, 2] < [1, 2, 3]) # True (shorter list is smaller)
Output:
Example
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 1, 2, 3, 1, 2, 3]
True
False
True
6
1
9
31
True
True
True
6. List Iteration (Traversal)
Example
fruits = ["apple", "banana", "cherry"]
# Simple for loop
for fruit in fruits:
print(fruit)
# With index using enumerate
for i, fruit in enumerate(fruits):
print(f"{i}: {fruit}")
# Using range and len
for i in range(len(fruits)):
print(f"Index {i} → {fruits[i]}")
# While loop
i = 0
while i < len(fruits):
print(fruits[i])
i += 1
# List comprehension (iteration)
lengths = [len(f) for f in fruits]
print(lengths) # [5, 6, 6]
Output:
| 0 | apple |
| 1 | banana |
| 2 | cherry |
| Index 0 | apple |
| Index 1 | banana |
| Index 2 | cherry |
7. Nested Lists (नेस्टेड लिस्ट)
Example
# 2D matrix
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
# Access element
print(matrix[1][1]) # 5 (row 1, col 1)
# Iterate over matrix
for row in matrix:
for val in row:
print(val, end=" ")
print()
# Matrix using list comprehension
identity = [[1 if i == j else 0 for j in range(3)] for i in range(3)]
print(identity)
# [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
# Flatten nested list
flat = [val for row in matrix for val in row]
print(flat) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
Output:
Example
5
1 2 3
4 5 6
7 8 9
[[1, 0, 0], [0, 1, 0], [0, 0, 1]]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
8. Copying Lists (कॉपी करना)
Example
import copy
original = [1, 2, [3, 4], 5]
# Assignment (NOT a copy – same reference)
ref = original
ref[0] = 99
print(original) # [99, 2, [3, 4], 5] ← original भी बदल गई!
# Shallow copy (3 ways)
original = [1, 2, [3, 4], 5]
shallow1 = original.copy()
shallow2 = original[:]
shallow3 = list(original)
shallow1[0] = 100
print(original) # [1, 2, [3, 4], 5] ← top-level unchanged
shallow1[2][0] = 999
print(original) # [1, 2, [999, 4], 5] ← nested list changed!
# Deep copy (fully independent)
original = [1, 2, [3, 4], 5]
deep = copy.deepcopy(original)
deep[2][0] = 999
print(original) # [1, 2, [3, 4], 5] ← unchanged
print(deep) # [1, 2, [999, 4], 5]
Output:
Example
[99, 2, [3, 4], 5]
[1, 2, [3, 4], 5]
[1, 2, [999, 4], 5]
[1, 2, [3, 4], 5]
[1, 2, [999, 4], 5]
9. List Unpacking (अनपैकिंग)
Example
# Basic unpacking
a, b, c = [1, 2, 3]
print(a, b, c) # 1 2 3
# Extended unpacking with *
first, *rest = [1, 2, 3, 4, 5]
print(first) # 1
print(rest) # [2, 3, 4, 5]
*start, last = [1, 2, 3, 4, 5]
print(start) # [1, 2, 3, 4]
print(last) # 5
first, *middle, last = [1, 2, 3, 4, 5]
print(first) # 1
print(middle) # [2, 3, 4]
print(last) # 5
# Swap variables
x, y = 10, 20
x, y = y, x
print(x, y) # 20 10
# Unpack nested
(a, b), c = [1, 2], 3
print(a, b, c) # 1 2 3
Output:
Example
1 2 3
1
[2, 3, 4, 5]
[1, 2, 3, 4]
5
1
[2, 3, 4]
5
20 10
1 2 3
10. Time Complexity (समय जटिलता)
| Operation | Average Case | Worst Case | Notes |
|---|---|---|---|
l[i] (index access) | O(1) | O(1) | Direct memory access |
l[i] = x (assignment) | O(1) | O(1) | Direct memory write |
append(x) | O(1) amortized | O(n) | Occasional resize |
insert(i, x) | O(n) | O(n) | Shift elements right |
pop() | O(1) | O(1) | Remove last |
pop(i) | O(n) | O(n) | Shift elements left |
remove(x) | O(n) | O(n) | Search + shift |
x in list | O(n) | O(n) | Linear search |
len(l) | O(1) | O(1) | Stored attribute |
l[a:b] (slice) | O(k) | O(k) | k = b-a elements |
l.sort() | O(n log n) | O(n log n) | Timsort |
l + m (concat) | O(k) | O(k) | k = len(m) |
min(l), max(l) | O(n) | O(n) | Full scan |
💡 Tip: जब frequently middle में insert/delete करना हो तो collections.deque या linked list prefer करें।11. Memory Layout
| ob_size | ob_alloc | *ob_item | ||
|---|---|---|---|---|
| (len) | (capacity) | (pointer) |
12. List vs Other Sequences
| Feature | List | Tuple | String | Array |
|---|---|---|---|---|
| Mutable | ✅ Yes | ❌ No | ❌ No | ✅ Yes |
| Ordered | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes |
| Duplicates | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes |
| Heterogeneous | ✅ Yes | ✅ Yes | ❌ (chars only) | ❌ (typed) |
| Memory | Medium | Less | Less | Least |
| Indexing | O(1) | O(1) | O(1) | O(1) |
| Use Case | General | Fixed data | Text | Numeric |
13. Real-World Examples (असली उपयोग)
Example
# Example 1: Shopping cart
cart = []
cart.append("laptop")
cart.append("mouse")
cart.append("keyboard")
cart.remove("mouse")
print("Cart:", cart) # Cart: ['laptop', 'keyboard']
# Example 2: Stack implementation (LIFO)
stack = []
stack.append(1) # push
stack.append(2)
stack.append(3)
top = stack.pop() # pop
print("Popped:", top) # Popped: 3
print("Stack:", stack) # Stack: [1, 2]
# Example 3: Queue implementation (FIFO) - better use deque
queue = []
queue.append("A") # enqueue
queue.append("B")
queue.append("C")
front = queue.pop(0) # dequeue (slow! O(n))
print("Dequeued:", front) # Dequeued: A
print("Queue:", queue) # Queue: ['B', 'C']
# Example 4: Frequency counter
words = ["apple", "banana", "apple", "cherry", "banana", "apple"]
freq = {}
for word in words:
freq[word] = freq.get(word, 0) + 1
print(freq) # {'apple': 3, 'banana': 2, 'cherry': 1}
Output:
| Cart | ['laptop', 'keyboard'] |
| Popped | 3 |
| Stack | [1, 2] |
| Dequeued | A |
| Queue | ['B', 'C'] |
| {'apple' | 3, 'banana': 2, 'cherry': 1} |
14. Common Pitfalls (सामान्य गलतियाँ)
Example
# ❌ Pitfall 1: Mutable default argument
def add_item(item, lst=[]): # lst हर call पर share होती है!
lst.append(item)
return lst
print(add_item("a")) # ['a']
print(add_item("b")) # ['a', 'b'] ← unexpected!
# ✅ Fix:
def add_item(item, lst=None):
if lst is None:
lst = []
lst.append(item)
return lst
# ❌ Pitfall 2: Modifying list while iterating
nums = [1, 2, 3, 4, 5]
for n in nums:
if n % 2 == 0:
nums.remove(n) # Skips elements!
print(nums) # [1, 3, 5] ← might miss some
# ✅ Fix: Iterate over a copy
for n in nums[:]:
if n % 2 == 0:
nums.remove(n)
# ❌ Pitfall 3: * creates shared references
grid = [[0] * 3] * 3
grid[0][0] = 9
print(grid) # [[9, 0, 0], [9, 0, 0], [9, 0, 0]] ← all rows changed!
# ✅ Fix:
grid = [[0] * 3 for _ in range(3)]
grid[0][0] = 9
print(grid) # [[9, 0, 0], [0, 0, 0], [0, 0, 0]]
15. Interview Questions (इंटरव्यू प्रश्न)
Q1: List और Tuple में क्या फर्क है?
Answer: List mutable होती है (change किया जा सकता है), Tuple immutable (fixed)। Tuples faster और less memory use करते हैं। Lists use करें जब data बदलना हो; Tuples जब data fixed हो (like coordinates)।
Q2: Python में list कैसे reverse करें?
Example
nums = [1, 2, 3, 4, 5]
# Method 1: reverse() - in-place
nums.reverse()
# Method 2: Slicing - new list
rev = nums[::-1]
# Method 3: reversed() - iterator
rev_iter = list(reversed(nums))
Q3: List में duplicates remove कैसे करें?
Example
nums = [1, 2, 2, 3, 3, 3, 4]
# Method 1: set (order lost)
unique = list(set(nums))
# Method 2: dict.fromkeys (order preserved - Python 3.7+)
unique_ordered = list(dict.fromkeys(nums))
print(unique_ordered) # [1, 2, 3, 4]
Q4: Two lists को zip करना?
Example
names = ["Alice", "Bob", "Charlie"]
scores = [95, 87, 92]
result = list(zip(names, scores))
print(result) # [('Alice', 95), ('Bob', 87), ('Charlie', 92)]
Q5: List को sort करना (custom key)?
Example
students = [("Alice", 25), ("Bob", 20), ("Charlie", 22)]
students.sort(key=lambda x: x[1]) # age से sort
print(students) # [('Bob', 20), ('Charlie', 22), ('Alice', 25)]
Q6: Largest और smallest N elements?
Example
import heapq
nums = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]
print(heapq.nlargest(3, nums)) # [9, 6, 5]
print(heapq.nsmallest(3, nums)) # [1, 1, 2]
Summary (सारांश)
| Topic | Key Point |
|---|---|
| Creation | [], list(), list(range(...)) |
| Indexing | 0-based, negative indexing supported |
| Slicing | [start:stop:step] |
| Mutability | Elements change/add/delete किए जा सकते हैं |
| Copy | = (reference), .copy() (shallow), deepcopy (deep) |
| Complexity | Access O(1), Search O(n), Sort O(n log n) |
| Unpacking | a, *b, c = list |
🎯 Practice: एक to-do list program बनाएं जिसमें add, remove, view, और search tasks हो।
⚠️ Common Mistakes (आम गलतियाँ)
Mistake 1: Using = for copying a list ❌
Example
original = [1, 2, 3, 4, 5]
copy = original # ❌ Ye copy nahi hai, same reference hai!
copy.append(6)
print(original) # [1, 2, 3, 4, 5, 6] 😱 Original bhi change ho gaya!
Output
[1, 2, 3, 4, 5, 6]
✅ Fix:copy = original.copy()yacopy = original[:]use करें।
Mistake 2: Modifying list while iterating ❌
Example
nums = [1, 2, 3, 4, 5, 6]
for n in nums:
if n % 2 == 0:
nums.remove(n) # ❌ Elements skip ho jaate hain!
print(nums)
Output
[1, 3, 5]
✅ Fix: Copy पर iterate करें:for n in nums[:]:या list comprehension use करें:nums = [n for n in nums if n % 2 != 0]
Mistake 3: Nested list with * operator ❌
Example
# ❌ Ye 3 same rows create karta hai (shared reference)
grid = [[0] * 3] * 3
grid[0][0] = 5
print(grid) # Saari rows change ho gayi!
Output
[[5, 0, 0], [5, 0, 0], [5, 0, 0]]
✅ Fix: List comprehension use करें: grid = [[0] * 3 for _ in range(3)]Mistake 4: Using mutable default argument ❌
Example
def add_item(item, lst=[]): # ❌ Default list shared hoti hai!
lst.append(item)
return lst
print(add_item("a"))
print(add_item("b")) # ❌ Expected ['b'] but got ['a', 'b']
Output
['a'] ['a', 'b']
✅ Fix:def add_item(item, lst=None):use करें और function body मेंif lst is None: lst = []
Mistake 5: Confusing append() with extend() ❌
Example
a = [1, 2, 3]
b = [4, 5, 6]
a.append(b) # ❌ Nested list ban jaati hai!
print(a) # [1, 2, 3, [4, 5, 6]]
a = [1, 2, 3]
a.extend(b) # ✅ Individual elements add hote hain
print(a) # [1, 2, 3, 4, 5, 6]
Output
[1, 2, 3, [4, 5, 6]] [1, 2, 3, 4, 5, 6]
Mistake 6: IndexError – accessing out of range index ❌
Example
fruits = ["apple", "banana", "cherry"]
# print(fruits[5]) # ❌ IndexError: list index out of range
# ✅ Fix: Length check karein
index = 5
if index < len(fruits):
print(fruits[index])
else:
print("Index out of range!")
Output
Index out of range!
Mistake 7: Using sort() vs sorted() confusion ❌
Example
nums = [3, 1, 4, 1, 5]
# sort() returns None (in-place sorting)
result = nums.sort()
print(result) # None ❌ (not a sorted list!)
print(nums) # [1, 1, 3, 4, 5] ✅ original list sorted
# sorted() returns new sorted list
nums = [3, 1, 4, 1, 5]
result = sorted(nums)
print(result) # [1, 1, 3, 4, 5] ✅
print(nums) # [3, 1, 4, 1, 5] (original unchanged)
Output
None [1, 1, 3, 4, 5] [1, 1, 3, 4, 5] [3, 1, 4, 1, 5]
✅ Key Takeaways (मुख्य बातें)
- 📌 List ordered और mutable होती है – elements का order maintain रहता है और change किया जा सकता है
- 📌 Heterogeneous data store कर सकते हैं – एक ही list में int, str, float, bool सब आ सकते हैं
- 📌 Indexing 0 से start होती है – negative indexing (
-1) से end से access करें - 📌 Slicing
[start:stop:step]– new list return करती है, original unchanged रहती है - 📌
=assignment copy नहीं बनाता –.copy(),[:], याcopy.deepcopy()use करें - 📌
append()single item add करता है,extend()iterable के सारे items add करता है - 📌 List comprehension traditional loop से faster और Pythonic है
- 📌 Time Complexity याद रखें – access O(1), search O(n), sort O(n log n), insert/delete O(n)
- 📌 Nested lists में shallow copy से inner lists share होती हैं –
deepcopy()use करें - 📌 List को iterate करते वक्त modify न करें – copy पर iterate करें या comprehension use करें
❓ FAQ (अक्सर पूछे जाने वाले प्रश्न)
Q1: List और Array में क्या difference है?
Answer: Python list heterogeneous data store करती है (mixed types), जबकि array.array sirf एक ही type का data store करती है। Arrays memory efficient होते हैं numerical data के लिए, लेकिन lists ज्यादा flexible हैं। NumPy arrays scientific computing के लिए best हैं।Q2: List में maximum कितने elements store हो सकते हैं?
Answer: Python lists का कोई hard limit नहीं है – sys.maxsize तक elements हो सकते हैं (64-bit system पर ~9.2 × 10¹⁸)। Practically, available RAM ही limit है।Q3: List comprehension और normal loop में कौन faster है?
Answer: List comprehension generally 30-50% faster होती है normal for loop से क्योंकि ये C level पर optimized implementation use करती है। लेकिन complex logic के लिए readability का ध्यान रखें।
Example
# Comprehension (faster ✅)
squares = [x**2 for x in range(1000)]
# Normal loop (slower)
squares = []
for x in range(1000):
squares.append(x**2)
Q4: del, remove(), और pop() में क्या difference है?
Answer: -del list[i]– index से delete करता है, कुछ return नहीं करता -list.remove(value)– first occurrence of value remove करता है -list.pop(i)– index से remove करके वो element return करता है -list.pop()– last element remove + return करता है (stack behavior)
Q5: List को reverse करने के कितने तरीके हैं?
Answer: तीन main तरीके: 1.list.reverse()– in-place, O(n), returns None 2.list[::-1]– new reversed list, O(n) extra space 3.list(reversed(list))– returns iterator, memory efficient
Q6: Empty list check करने का best way क्या है?
Answer: Pythonic way है direct truthiness check:
python example
my_list = []
# ✅ Pythonic (recommended)
if not my_list:
print("List is empty")
# ❌ Non-Pythonic
if len(my_list) == 0:
print("List is empty")Output
List is empty
Q7: sort() और sorted() में क्या अंतर है?
Answer:sort()in-place sorting करता है (original list modify हो जाती है, returnsNone)।sorted()new sorted list return करता है (original unchanged)।sorted()किसी भी iterable पर काम करता है,sort()सिर्फ lists पर।
Q8: List को thread-safe कैसे बनाएं?
Answer: Python lists thread-safe नहीं हैं। Multi-threading मेंthreading.Lock()use करें याqueue.Queueuse करें जो internally thread-safe है।
🎯 Interview Questions (विस्तृत इंटरव्यू प्रश्न)
Q1: Python List internally कैसे implement होती है?
Answer: Python list internally एक dynamic array of pointers है। ये contiguous memory block में object references (pointers) store करती है। जब list full हो जाती है तो over-allocation strategy use होती है (approximately 1.125x growth) ताकि हर append O(1) amortized रहे।
Q2: List comprehension vs map() + lambda – कौन better है?
Answer: List comprehension ज्यादातर cases में preferred है क्योंकि ये readable है और slightly faster है।map()तब useful है जब existing function directly apply करनी हो (जैसेmap(str, nums))। Lambda + map combination list comprehension से slower होती है।
Example
nums = [1, 2, 3, 4, 5]
# List comprehension (✅ Preferred)
squares = [x**2 for x in nums]
# map + lambda
squares = list(map(lambda x: x**2, nums))
# map with existing function (✅ Good use case)
str_nums = list(map(str, nums))
print(str_nums)
Output
['1', '2', '3', '4', '5']
Q3: Shallow copy और Deep copy में practical difference क्या है?
Answer: Shallow copy सिर्फ top-level elements copy करती है – nested mutable objects (like inner lists) share होते हैं। Deep copy recursively सब कुछ copy करती है। Nested structures (list of lists) में हमेशा copy.deepcopy() use करें।Q4: list.sort() कौन सा algorithm use करता है?
Answer: Python Timsort algorithm use करता है (Tim Peters द्वारा designed)। ये merge sort + insertion sort का hybrid है। Time complexity: Best O(n), Average/Worst O(n log n)। ये stable sort है (equal elements का order preserve होता है)।
Q5: List में element find करने के efficient तरीके क्या हैं?
Answer: - Unsorted list:inoperator – O(n) linear search - Sorted list:bisectmodule – O(log n) binary search - Frequent lookups: List कोsetमें convert करें – O(1) lookup
Example
import bisect
sorted_list = [1, 3, 5, 7, 9, 11, 13]
index = bisect.bisect_left(sorted_list, 7)
found = sorted_list[index] == 7
print(f"Found 7: {found}, at index: {index}")
Output
Found 7: True, at index: 3
Q6: List slicing internally कैसे काम करती है?
Answer: Slicing एक new list create करती है (shallow copy)।a[1:4]internallylist.__getitem__(slice(1, 4, None))call करती है। ये original list modify नहीं करती। Memory: O(k) extra space जहां k = stop - start।
Q7: *args और list unpacking कैसे related हैं?
Answer:*argsfunction में variable arguments accept करता है – internally एक tuple बनता है। List unpacking (*list) किसी भी iterable को expand करती है। दोनों PEP 3132 (extended unpacking) पर based हैं।
Example
def add(*args):
return sum(args)
nums = [1, 2, 3, 4, 5]
print(add(*nums)) # List unpack hokar individual args बन जाते हैं
# Extended unpacking
first, *middle, last = [10, 20, 30, 40, 50]
print(f"First: {first}, Middle: {middle}, Last: {last}")
Output
15 First: 10, Middle: [20, 30, 40], Last: 50
Q8: List memory optimization कैसे करें?
Answer: - Large homogeneous data के लिएarray.arrayया NumPy use करें - Generators use करें जब full list memory में load करना जरूरी न हो -__slots__use करें objects की list में -sys.getsizeof()से memory track करें
Example
import sys
# List vs Generator memory comparison
list_mem = sys.getsizeof([x**2 for x in range(1000)])
gen_mem = sys.getsizeof(x**2 for x in range(1000))
print(f"List memory: {list_mem} bytes")
print(f"Generator memory: {gen_mem} bytes")
Output
List memory: 8856 bytes Generator memory: 200 bytes
Q9: List को function argument के रूप में pass करने पर क्या होता है?
Answer: Python में lists pass by reference (actually pass by object reference) होती हैं। Function में list modify करने पर original list भी change हो जाती है। Agar original preserve करना है तो copy pass करें।
Example
def modify(lst):
lst.append(99) # Original list modify ho jaegi
def safe_modify(lst):
lst = lst.copy() # Local copy
lst.append(99)
return lst
original = [1, 2, 3]
modify(original)
print(original) # [1, 2, 3, 99] – Modified!
original = [1, 2, 3]
new = safe_modify(original)
print(original) # [1, 2, 3] – Unchanged ✅
print(new) # [1, 2, 3, 99]
Output
[1, 2, 3, 99] [1, 2, 3] [1, 2, 3, 99]
Q10: List vs Deque – कब कौन use करें?
Answer: - List: Random access (index), append/pop from end → O(1) - Deque: append/pop from both ends → O(1), but random access → O(n) - Queue/BFS implement करने के लिए collections.deque use करें, general purpose के लिए listExample
from collections import deque
# List - slow at front operations
# list.pop(0) → O(n), list.insert(0, x) → O(n)
# Deque - fast at both ends
dq = deque([1, 2, 3])
dq.appendleft(0) # O(1)
dq.pop() # O(1)
dq.popleft() # O(1)
print(list(dq))
Output
[1, 2]
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Python Lists – Complete Guide.
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, lists
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 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 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 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.