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 List के सभी built-in methods का complete reference – append, extend, insert, remove, pop, sort, reverse, index, count, copy, clear – examples और time complexity के साथ।
Quick Reference Table (सभी Methods एक नज़र में)
| Method | Syntax | Description | Returns | Complexity |
|---|---|---|---|---|
append() | l.append(x) | अंत में element add करे | None | O(1) amortized |
extend() | l.extend(iterable) | Iterable के सभी elements add करे | None | O(k) |
insert() | l.insert(i, x) | Position i पर x insert करे | None | O(n) |
remove() | l.remove(x) | पहला x हटाए | None | O(n) |
pop() | l.pop([i]) | Index i का element हटाए व return करे | Element | O(1)/O(n) |
clear() | l.clear() | सभी elements हटाए | None | O(n) |
index() | l.index(x[, s, e]) | x का पहला index return करे | int | O(n) |
count() | l.count(x) | x की गिनती return करे | int | O(n) |
sort() | l.sort(key, reverse) | In-place sort करे | None | O(n log n) |
reverse() | l.reverse() | In-place reverse करे | None | O(n) |
copy() | l.copy() | Shallow copy return करे | List | O(n) |
2. extend() – Multiple Elements जोड़ना
किसी भी iterable के सभी elements को list में add करता है।
Example
nums = [1, 2, 3]
# Extend with list
nums.extend([4, 5, 6])
print(nums) # [1, 2, 3, 4, 5, 6]
# Extend with tuple
nums.extend((7, 8))
print(nums) # [1, 2, 3, 4, 5, 6, 7, 8]
# Extend with string (chars)
letters = ['a', 'b']
letters.extend("cde")
print(letters) # ['a', 'b', 'c', 'd', 'e']
# Extend with range
nums = [1, 2, 3]
nums.extend(range(4, 8))
print(nums) # [1, 2, 3, 4, 5, 6, 7]
# Extend with generator
nums.extend(x**2 for x in range(3))
print(nums) # [1, 2, 3, 4, 5, 6, 7, 0, 1, 4]
# Equivalent to +=
a = [1, 2]
a += [3, 4] # same as a.extend([3, 4])
print(a) # [1, 2, 3, 4]
Output:
Example
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 7, 8]
['a', 'b', 'c', 'd', 'e']
[1, 2, 3, 4, 5, 6, 7]
[1, 2, 3, 4, 5, 6, 7, 0, 1, 4]
[1, 2, 3, 4]
3. insert() – किसी Position पर Insert करना
list.insert(index, element) – किसी specific index पर element insert करता है।
Example
nums = [1, 2, 3, 4, 5]
# Insert at beginning (index 0)
nums.insert(0, 0)
print(nums) # [0, 1, 2, 3, 4, 5]
# Insert at specific position
nums.insert(3, 99)
print(nums) # [0, 1, 2, 99, 3, 4, 5]
# Insert at end (large index)
nums.insert(100, 999) # index बड़ा हो तो end में add होता है
print(nums) # [0, 1, 2, 99, 3, 4, 5, 999]
# Negative index
nums.insert(-1, 888) # आखिरी से पहले
print(nums) # [0, 1, 2, 99, 3, 4, 5, 888, 999]
# Insert list as element
data = [10, 20, 30]
data.insert(1, [15, 16])
print(data) # [10, [15, 16], 20, 30]
Output:
Example
[0, 1, 2, 3, 4, 5]
[0, 1, 2, 99, 3, 4, 5]
[0, 1, 2, 99, 3, 4, 5, 999]
[0, 1, 2, 99, 3, 4, 5, 888, 999]
[10, [15, 16], 20, 30]
⚠️ Warning: insert() O(n) है क्योंकि elements shift करने पड़ते हैं।4. remove() – Value से Element हटाना
पहली occurrence को value के basis पर हटाता है।
Example
fruits = ["apple", "banana", "cherry", "banana", "date"]
# Remove first occurrence
fruits.remove("banana")
print(fruits) # ['apple', 'cherry', 'banana', 'date']
# Remove again
fruits.remove("banana")
print(fruits) # ['apple', 'cherry', 'date']
# Remove non-existent element → ValueError
try:
fruits.remove("mango")
except ValueError as e:
print(f"Error: {e}") # Error: list.remove(x): x not in list
# Safe remove with check
if "cherry" in fruits:
fruits.remove("cherry")
print(fruits) # ['apple', 'date']
# Remove all occurrences
nums = [1, 2, 3, 2, 4, 2, 5]
while 2 in nums:
nums.remove(2)
print(nums) # [1, 3, 4, 5]
# Better approach with list comprehension
nums = [1, 2, 3, 2, 4, 2, 5]
nums = [x for x in nums if x != 2]
print(nums) # [1, 3, 4, 5]
Output:
Example
['apple', 'cherry', 'banana', 'date']
['apple', 'cherry', 'date']
Error: list.remove(x): x not in list
['apple', 'date']
[1, 3, 4, 5]
[1, 3, 4, 5]
5. pop() – Index से Element हटाना
Index के basis पर element हटाता है और return करता है।
Example
stack = [10, 20, 30, 40, 50]
# Pop last element (default)
last = stack.pop()
print(last) # 50
print(stack) # [10, 20, 30, 40]
# Pop at specific index
third = stack.pop(2)
print(third) # 30
print(stack) # [10, 20, 40]
# Pop first element (O(n) - avoid for large lists)
first = stack.pop(0)
print(first) # 10
print(stack) # [20, 40]
# Negative index
stack.pop(-1) # same as stack.pop()
print(stack) # [20]
# Pop from empty list → IndexError
try:
[].pop()
except IndexError as e:
print(f"Error: {e}") # Error: pop from empty list
# Stack implementation using pop
stack = []
stack.append("a") # push
stack.append("b")
stack.append("c")
while stack:
print("Pop:", stack.pop()) # LIFO order
Output:
| Error | pop from empty list |
| Pop | c |
| Pop | b |
| Pop | a |
6. clear() – सभी Elements हटाना
List को empty कर देता है।
Example
data = [1, 2, 3, 4, 5]
print(len(data)) # 5
data.clear()
print(data) # []
print(len(data)) # 0
# clear() vs reassignment
a = [1, 2, 3]
b = a # b references same list
a.clear() # In-place: both a and b are empty
print(a) # []
print(b) # [] ← b भी empty हो गई!
# vs
a = [1, 2, 3]
b = a
a = [] # a को new list assign किया
print(a) # []
print(b) # [1, 2, 3] ← b unchanged!
Output:
Example
5
[]
0
[]
[]
[]
[1, 2, 3]
7. index() – Element का Index ढूँढना
list.index(x, start=0, end=len(list)) – पहली occurrence का index return करता है।
Example
fruits = ["apple", "banana", "cherry", "banana", "date"]
# Basic index search
print(fruits.index("banana")) # 1 (पहली occurrence)
print(fruits.index("date")) # 4
# Search in range [start, end)
print(fruits.index("banana", 2)) # 3 (index 2 से आगे खोजो)
print(fruits.index("banana", 2, 5)) # 3
# Not found → ValueError
try:
fruits.index("mango")
except ValueError:
print("Not found!") # Not found!
# Safe index with try/except
def safe_index(lst, val):
try:
return lst.index(val)
except ValueError:
return -1
print(safe_index(fruits, "cherry")) # 2
print(safe_index(fruits, "mango")) # -1
# Find all indices
nums = [1, 2, 3, 2, 4, 2]
indices = [i for i, x in enumerate(nums) if x == 2]
print(indices) # [1, 3, 5]
Output:
Example
1
4
3
3
Not found!
2
-1
[1, 3, 5]
8. count() – Occurrences गिनना
किसी value की list में कितनी बार है, return करता है।
Example
nums = [1, 2, 3, 2, 4, 2, 5, 2]
print(nums.count(2)) # 4
print(nums.count(1)) # 1
print(nums.count(99)) # 0 (not found → 0)
# String list
words = ["hello", "world", "hello", "python", "hello"]
print(words.count("hello")) # 3
print(words.count("python")) # 1
# Count nested element
data = [1, [2, 3], [2, 3], "a"]
print(data.count([2, 3])) # 2
print(data.count(2)) # 0 (direct 2, not nested)
# Frequency distribution
from collections import Counter
text = ["a", "b", "a", "c", "b", "a", "d"]
freq = Counter(text)
print(freq) # Counter({'a': 3, 'b': 2, 'c': 1, 'd': 1})
print(freq.most_common(2)) # [('a', 3), ('b', 2)]
Output:
Example
4
1
0
3
1
2
0
Counter({'a': 3, 'b': 2, 'c': 1, 'd': 1})
[('a', 3), ('b', 2)]
9. sort() – In-place Sorting
list.sort(key=None, reverse=False) – List को in-place sort करता है।
Example
# Basic sort (ascending)
nums = [3, 1, 4, 1, 5, 9, 2, 6]
nums.sort()
print(nums) # [1, 1, 2, 3, 4, 5, 6, 9]
# Descending sort
nums.sort(reverse=True)
print(nums) # [9, 6, 5, 4, 3, 2, 1, 1]
# String sort
words = ["banana", "apple", "cherry", "date"]
words.sort()
print(words) # ['apple', 'banana', 'cherry', 'date']
# Case-insensitive sort
words = ["Banana", "apple", "Cherry", "date"]
words.sort(key=str.lower)
print(words) # ['apple', 'Banana', 'Cherry', 'date']
# Sort by length
words.sort(key=len)
print(words) # ['date', 'apple', 'Banana', 'Cherry']
# Sort by multiple criteria (tuples)
students = [("Alice", 85), ("Bob", 92), ("Charlie", 85), ("Dave", 78)]
students.sort(key=lambda x: (-x[1], x[0])) # Score desc, name asc
print(students)
# [('Bob', 92), ('Alice', 85), ('Charlie', 85), ('Dave', 78)]
# Sort objects
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def __repr__(self):
return f"Person({self.name}, {self.age})"
people = [Person("Alice", 30), Person("Bob", 25), Person("Charlie", 35)]
people.sort(key=lambda p: p.age)
print(people) # [Person(Bob, 25), Person(Alice, 30), Person(Charlie, 35)]
Output:
Example
[1, 1, 2, 3, 4, 5, 6, 9]
[9, 6, 5, 4, 3, 2, 1, 1]
['apple', 'banana', 'cherry', 'date']
['apple', 'Banana', 'Cherry', 'date']
['date', 'apple', 'Banana', 'Cherry']
[('Bob', 92), ('Alice', 85), ('Charlie', 85), ('Dave', 78)]
[Person(Bob, 25), Person(Alice, 30), Person(Charlie, 35)]
sort() vs sorted()
| Feature | list.sort() | sorted() |
|---|---|---|
| In-place | ✅ Yes (modifies original) | ❌ No (new list) |
| Returns | None | New sorted list |
| Works on | Lists only | Any iterable |
| Memory | O(1) extra | O(n) extra |
| Use when | Original order unneeded | Original preserved |
Example
nums = [3, 1, 4, 1, 5]
# sort() - modifies in place, returns None
result = nums.sort()
print(result) # None
print(nums) # [1, 1, 3, 4, 5] ← modified
# sorted() - returns new list
nums = [3, 1, 4, 1, 5]
new = sorted(nums)
print(new) # [1, 1, 3, 4, 5]
print(nums) # [3, 1, 4, 1, 5] ← unchanged!
# sorted() works on any iterable
print(sorted("python")) # ['h', 'n', 'o', 'p', 't', 'y']
print(sorted({3, 1, 4})) # [1, 3, 4]
print(sorted((5, 2, 8))) # [2, 5, 8]
Output:
Example
None
[1, 1, 3, 4, 5]
[1, 1, 3, 4, 5]
[3, 1, 4, 1, 5]
['h', 'n', 'o', 'p', 't', 'y']
[1, 3, 4]
[2, 5, 8]
10. reverse() – In-place Reversal
List को in-place reverse करता है।
Example
nums = [1, 2, 3, 4, 5]
nums.reverse()
print(nums) # [5, 4, 3, 2, 1]
# String list
words = ["first", "second", "third"]
words.reverse()
print(words) # ['third', 'second', 'first']
# reverse() vs reversed() vs slicing
nums = [1, 2, 3, 4, 5]
# Method 1: reverse() - in-place, returns None
nums.reverse() # [5, 4, 3, 2, 1]
# Method 2: slicing - new list
rev_slice = nums[::-1] # [1, 2, 3, 4, 5]
# Method 3: reversed() - iterator (lazy)
for x in reversed(nums):
print(x, end=" ") # 1 2 3 4 5
Output:
Example
[5, 4, 3, 2, 1]
['third', 'second', 'first']
1 2 3 4 5
| Method | Returns | In-place | Lazy |
|---|---|---|---|
reverse() | None | ✅ Yes | ❌ No |
[::-1] | New list | ❌ No | ❌ No |
reversed() | Iterator | ❌ No | ✅ Yes |
11. copy() – Shallow Copy
Example
original = [1, 2, [3, 4], 5]
# copy() method
shallow = original.copy()
shallow[0] = 99
print(original) # [1, 2, [3, 4], 5] ← top-level unchanged
print(shallow) # [99, 2, [3, 4], 5]
# But nested objects are shared!
shallow[2].append(99)
print(original) # [1, 2, [3, 4, 99], 5] ← nested changed!
print(shallow) # [99, 2, [3, 4, 99], 5]
# 3 ways to shallow copy
a = [1, 2, 3]
b = a.copy() # Method 1
c = a[:] # Method 2
d = list(a) # Method 3
print(b is a) # False (different object)
print(b == a) # True (same content)
Output:
Example
[1, 2, [3, 4], 5]
[99, 2, [3, 4], 5]
[1, 2, [3, 4, 99], 5]
[99, 2, [3, 4, 99], 5]
False
True
12. Chaining Methods
Example
# Methods return None, so can't chain like this:
# nums.append(1).append(2) ← Error!
# But you can do this:
nums = []
nums.append(1)
nums.append(2)
nums.append(3)
nums.sort()
nums.reverse()
print(nums) # [3, 2, 1]
# Alternative: use list comprehension or sorted()
result = sorted([3, 1, 4, 1, 5], reverse=True)
print(result) # [5, 4, 3, 1, 1]
Output:
Example
[3, 2, 1]
[5, 4, 3, 1, 1]
13. del Statement
del keyword list methods नहीं है, लेकिन important है।
Example
nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Delete single element
del nums[3]
print(nums) # [0, 1, 2, 4, 5, 6, 7, 8, 9]
# Delete slice
del nums[2:5]
print(nums) # [0, 1, 6, 7, 8, 9]
# Delete step slice
del nums[::2]
print(nums) # [1, 7, 9]
# Delete entire list variable
del nums
# print(nums) # NameError: name 'nums' is not defined
Output:
Example
[0, 1, 2, 4, 5, 6, 7, 8, 9]
[0, 1, 6, 7, 8, 9]
[1, 7, 9]
14. Interview Questions (इंटरव्यू प्रश्न)
Q1: append() और extend() में क्या फर्क है?
append()किसी भी object को (including list) single element की तरह add करता है।extend()iterable के हर element को individually add करता है।
Q2: remove() और pop() में क्या difference है?
remove(x)valuexकी पहली occurrence हटाता है।pop(i)indexiपर का element हटाता और return करता है।remove()value-based,pop()index-based है।
Q3: sort() None क्यों return करता है?
यह Python का design principle है – in-place operationsNonereturn करते हैं ताकि programmer confuse न हो कि new list है या modified। यदि new sorted list चाहिए,sorted()use करें।
Q4: List को efficiently reverse करने का best तरीका?
Example
# For in-place: reverse() - O(n), O(1) space
nums.reverse()
# For new list: slicing
rev = nums[::-1]
# For iteration only: reversed() - no extra memory
for x in reversed(nums):
print(x)
Q5: List में most frequent element कैसे ढूँढें?
Example
nums = [1, 2, 2, 3, 3, 3, 4]
most_freq = max(set(nums), key=nums.count)
print(most_freq) # 3
# Or with Counter (more efficient)
from collections import Counter
print(Counter(nums).most_common(1)[0][0]) # 3
Summary Cheatsheet
Example
l = [3, 1, 4, 1, 5, 9, 2, 6]
l.append(7) # [3, 1, 4, 1, 5, 9, 2, 6, 7]
l.extend([8, 9]) # [3, 1, 4, 1, 5, 9, 2, 6, 7, 8, 9]
l.insert(0, 0) # [0, 3, 1, 4, 1, 5, 9, 2, 6, 7, 8, 9]
l.remove(1) # removes first 1
l.pop() # removes & returns last
l.pop(0) # removes & returns first
l.index(5) # position of 5
l.count(1) # how many 1s
l.sort() # in-place ascending sort
l.sort(reverse=True) # descending
l.sort(key=lambda x: x) # custom key
l.reverse() # in-place reverse
copy = l.copy() # shallow copy
l.clear() # empty the list
⚠️ Common Mistakes
Mistake 1: sort() का result variable में assign करना ❌
Example
nums = [3, 1, 4, 1, 5]
result = nums.sort() # ❌ sort() returns None!
print(result) # None
print(nums) # [1, 1, 3, 4, 5] ← list modify हो गई
Output
None [1, 1, 3, 4, 5]
✅ Fix: अगर new sorted list चाहिए तोsorted()use करें:result = sorted(nums)
Mistake 2: Loop में list modify करना ❌
Example
nums = [1, 2, 3, 4, 5, 6]
# ❌ Removing items while iterating
for num in nums:
if num % 2 == 0:
nums.remove(num)
print(nums) # [1, 3, 5] नहीं मिलेगा!
Output
[1, 3, 5, 6]
✅ Fix: List comprehension use करें: nums = [x for x in nums if x % 2 != 0]Mistake 3: append() में list pass करना (nested list बन जाती है) ❌
Example
a = [1, 2, 3]
a.append([4, 5]) # ❌ nested list!
print(a)
Output
[1, 2, 3, [4, 5]]
✅ Fix: Flat list चाहिए तोextend()use करें:a.extend([4, 5])→[1, 2, 3, 4, 5]
Mistake 4: copy() से Deep Copy की उम्मीद रखना ❌
Example
original = [[1, 2], [3, 4]]
shallow = original.copy()
shallow[0].append(99)
print(original) # ❌ original भी change हो गया!
print(shallow)
Output
[[1, 2, 99], [3, 4]] [[1, 2, 99], [3, 4]]
✅ Fix: Nested objects के लिए import copy; deep = copy.deepcopy(original) use करेंMistake 5: remove() को non-existent value पर call करना ❌
Example
fruits = ["apple", "banana"]
# ❌ ValueError अगर element नहीं है
try:
fruits.remove("mango")
except ValueError as e:
print(f"Error: {e}")
Output
Error: list.remove(x): x not in list
✅ Fix: पहले check करें: if "mango" in fruits: fruits.remove("mango")Mistake 6: sort() mixed types पर use करना ❌
Example
mixed = [1, "two", 3, "four"]
try:
mixed.sort() # ❌ Python 3 में TypeError!
except TypeError as e:
print(f"Error: {e}")
Output
Error: '<' not supported between instances of 'str' and 'int'
✅ Fix: Sorting से पहले ensure करें कि सभी elements comparable हों (same type या custom key)
Mistake 7: insert() का performance underestimate करना ❌
python example
# ❌ Beginning में repeatedly insert करना = O(n²)
result = []
for i in range(5):
result.insert(0, i) # हर बार सारे elements shift होते हैं!
print(result)Output
[4, 3, 2, 1, 0]
✅ Fix:collections.dequeuse करें जिसमेंappendleft()O(1) है, याappend()+reverse()
✅ Key Takeaways
- 📌 append() vs extend():
append()single element add करता है (list भी as one element),extend()iterable के हर element को individually add करता है - 📌 In-place methods return None:
sort(),reverse(),append(),extend(),insert(),remove(),clear()सभीNonereturn करते हैं — result assign मत करो! - 📌 pop() is dual-purpose: बिना argument = last element (O(1)), with index = specific position (O(n) for non-last)
- 📌 remove() vs pop() vs del:
remove(value)value-based,pop(index)index-based + returns,del lst[i]index-based without return - 📌 sort() uses Timsort: O(n log n) worst case, O(n) best case (nearly sorted data), stable sort (equal elements maintain order)
- 📌 copy() is shallow only: Nested mutable objects अभी भी shared रहते हैं — deep copy के लिए
copy.deepcopy()use करें - 📌 Time Complexity याद रखें:
append()/pop()= O(1),insert(0)/pop(0)= O(n),sort()= O(n log n) - 📌 index() ValueError दे सकता है: Production code में हमेशा try-except या
if x in listcheck use करें - 📌 sorted() vs sort(): sorted() कोई भी iterable ले सकता है और new list return करता है, sort() सिर्फ lists पर काम करता है
- 📌 Loop में modification avoid करें: Iterating list को modify करने से unexpected results आते हैं — list comprehension prefer करें
❓ FAQ
Q1: append() और + operator में क्या difference है?
Answer: append(x) single element add करता है in-place (O(1)), जबकि + operator दो lists को concatenate करके new list बनाता है (O(n+m))। अगर repeatedly items add करने हैं तो append() ज़्यादा efficient है। += internally extend() जैसा काम करता है (in-place modify करता है)।
Q2: List को sort करते समय key parameter कैसे काम करता है?
Answer: key एक function accept करता है जो हर element पर apply होता है, और sorting उस function के return value पर होती है। Original elements change नहीं होते, बस comparison key function के output से होता है। Example: words.sort(key=len) words को उनकी length के basis पर sort करता है।
Q3: clear() और del list[:] में क्या difference है?
Answer: दोनों same काम करते हैं — list को empty कर देते हैं in-place। clear() ज़्यादा readable है (Python 3.3+ में available)। del list[:] slice deletion है जो same effect देता है। दोनों case में references (aliases) भी affected होती हैं।
Q4: pop(0) slow क्यों है? Alternative क्या है?
Answer: pop(0) O(n) है क्योंकि बाकी सारे elements एक position left shift होते हैं। अगर frequently front से remove करना है तो collections.deque use करें जिसका popleft() O(1) है। Small lists (< 1000 items) के लिए performance difference negligible होता है।
Q5: sort() stable sort है — इसका मतलब क्या है?
Answer: Stable sort का मतलब है कि अगर दो elements equal हैं (key function same value return करे), तो उनका original order maintain रहेगा। यह multi-level sorting में बहुत useful है — पहले secondary key से sort करो, फिर primary key से।
Q6: Nested list को flat कैसे करें list methods से?
Answer:
Example
# Single level nesting
nested = [[1, 2], [3, 4], [5, 6]]
flat = []
for sublist in nested:
flat.extend(sublist)
print(flat) # [1, 2, 3, 4, 5, 6]
# Or with list comprehension
flat = [item for sublist in nested for item in sublist]
print(flat) # [1, 2, 3, 4, 5, 6]
Output
[1, 2, 3, 4, 5, 6] [1, 2, 3, 4, 5, 6]
Q7: reverse() और sort(reverse=True) में difference क्या है?
Answer: reverse() simply element order उलटा कर देता है (O(n)) — no comparison। sort(reverse=True) descending order में sort करता है (O(n log n)) — elements compare होते हैं। [3,1,4].reverse() → [4,1,3], [3,1,4].sort(reverse=True) → [4,3,1]।
Q8: List method call करते समय None print हो रहा है — क्यों?
Answer: In-place methods (append, sort, reverse, etc.) None return करते हैं। अगर आप print(list.append(5)) लिखेंगे तो None print होगा। सही approach: पहले method call करें, फिर list print करें separately।
🎯 Interview Questions (Advanced)
Q1: Python List internally कैसे implement होती है?
Answer: Python list internally एक dynamic array (array of pointers) है। यह contiguous memory block में PyObject pointers store करती है। जब capacity full होती है, तो Python roughly 1.125x (over-allocation formula) size grow करता है, इसलिए append() amortized O(1) है। यह C array-list implementation पर based है (CPython में listobject.c)।
Q2: sort() कौनसा algorithm use करता है? इसकी properties बताओ।
Answer: Python Timsort algorithm use करता है (Tim Peters ने design किया)। Properties:
- Best case: O(n) — nearly sorted data
- Average/Worst: O(n log n)
- Space: O(n) worst case
- Stable: Yes (equal elements का order preserve)
- Adaptive: Existing runs (sorted subsequences) detect करता है
- यह merge sort + insertion sort का hybrid है
Q3: list.copy() और copy.deepcopy() में detailed difference बताओ।
Answer:
Example
import copy
original = [[1, 2], {"a": 3}]
shallow = original.copy() # Level 1 copy only
deep = copy.deepcopy(original) # All levels recursively copied
original[0].append(99)
print(shallow[0]) # [1, 2, 99] ← affected!
print(deep[0]) # [1, 2] ← unaffected!
Output
[1, 2, 99] [1, 2]
copy() सिर्फ top-level references copy करता है। Nested objects same memory location point करते हैं। deepcopy() recursively सभी objects की independent copies बनाता है।
Q4: List में pop(0) repeatedly call करना vs deque.popleft() — Performance difference?
Answer: list.pop(0) O(n) है (n-1 elements shift), repeatedly call = O(n²)। deque.popleft() O(1) है (doubly-linked list)। 10 lakh elements वाली list से 1 lakh items front से remove करना: list = ~seconds, deque = ~milliseconds। Rule: अगर front operations frequent हैं, deque use करें।
Q5: a += [1,2] और a = a + [1,2] में internal difference क्या है?
Answer:
a += [1,2]→ callsa.__iadd__([1,2])→ in-place extend (same object,id(a)same रहता है)a = a + [1,2]→ callsa.__add__([1,2])→ new list बनता है (different object,id(a)change)
यह matter करता है जब दूसरा variable same list reference कर रहा हो:
Example
a = [1, 2, 3]
b = a
a += [4, 5] # b भी [1,2,3,4,5] हो जाएगा (same object)
a = [1, 2, 3]
b = a
a = a + [4, 5] # b अभी भी [1,2,3] (different object)
Q6: Custom object की list sort करनी है multiple criteria से — कैसे करें?
Answer:
Example
from functools import cmp_to_key
students = [("Alice", 85), ("Bob", 92), ("Charlie", 85)]
# Method 1: Tuple key (primary desc, secondary asc)
students.sort(key=lambda s: (-s[1], s[0]))
print(students)
# Method 2: Multiple stable sorts (reverse order of priority)
students.sort(key=lambda s: s[0]) # secondary: name asc
students.sort(key=lambda s: s[1], reverse=True) # primary: score desc
print(students)
Output
[('Bob', 92), ('Alice', 85), ('Charlie', 85)]
[('Bob', 92), ('Alice', 85), ('Charlie', 85)]Q7: List method index() O(n) है — faster search कैसे करें?
Answer: Options:
- Sorted list:
bisect.bisect_left()— O(log n) binary search - Frequent lookups:
setयाdictuse करें — O(1) average - Index mapping:
{val: idx for idx, val in enumerate(lst)}— O(n) build, O(1) query
Example
import bisect
sorted_list = [1, 3, 5, 7, 9, 11, 13]
idx = bisect.bisect_left(sorted_list, 7)
print(idx) # 3 (O(log n))
Output
3
Q8: list.sort() और sorted() internally same algorithm use करते हैं?
Answer: हाँ, दोनों Timsort use करते हैं। Difference implementation level पर है:
list.sort()→ in-place modify, list temporarily empty state में जाती है sorting के दौरानsorted()→ new list allocate करता है, original untouched- Performance लगभग same है, बस
sorted()extra O(n) memory use करता है new list के लिए
Q9: Thread-safe हैं list methods?
Answer: CPython में GIL (Global Interpreter Lock) के कारण individual list operations (append, pop) atomically execute होती हैं — technically thread-safe। But compound operations (check-then-act: if x in list: list.remove(x)) thread-safe नहीं हैं। Production multi-threaded code में threading.Lock() या queue.Queue use करें।
Q10: Memory efficient list alternatives कब use करने चाहिए?
Answer:
| Scenario | Alternative | Benefit |
|---|---|---|
| Only integers | array.array('i', [...]) | ~4x less memory |
| Fixed size numeric | numpy.array | Vectorized ops + less memory |
| FIFO/LIFO | collections.deque | O(1) both ends |
| Immutable | tuple | Hashable, slightly faster |
| Large sorted data | bisect module | O(log n) search |
python example
import sys
from array import array
lst = list(range(1000))
arr = array('i', range(1000))
print(f"List: {sys.getsizeof(lst)} bytes")
print(f"Array: {sys.getsizeof(arr)} bytes")Output
List: 8856 bytes Array: 4064 bytes
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Python List Methods – All Built-in Methods.
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, list
Related Python Master Course Topics
Continue learning this concept
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 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.