Python List म्हणजे काय? Practical Examples सह Python List सविस्तर शिका

तुम्ही जर Python शिकायला नुकतीच सुरुवात केली असेल, तर तुम्हाला “List” हा शब्द नक्कीच ऐकायला मिळाला असेल. Python मधील सगळ्यात जास्त वापरल्या जाणाऱ्या Data Structures पैकी List ही एक आहे. जवळपास प्रत्येक Python Program मध्ये कधी ना कधी List वापरली जातेच.

तर मग प्रश्न असा येतो की Python List म्हणजे नक्की काय? सोप्या भाषेत सांगायचं झालं तर, List म्हणजे एका ठिकाणी अनेक Values एकत्र Store करण्याची पद्धत. समजा तुम्हाला तुमच्या वर्गातील ५ मित्रांची नावं एका ठिकाणी ठेवायची आहेत, तर त्यासाठी तुम्ही ५ वेगवेगळे Variables बनवण्याऐवजी एकच List वापरू शकता.

Beginners नी List शिकणं का गरजेचं आहे? कारण Python मधील जवळपास प्रत्येक Real-world Application मध्ये – मग ते Data Analysis असो, Web Development असो किंवा Machine Learning असो – List चा वापर केला जातो. Interview मध्ये सुद्धा List संबंधित Questions हमखास विचारले जातात.

List चा वापर कुठे कुठे होतो? Student Management System मध्ये Students ची यादी ठेवायला, Shopping Cart मध्ये Products ठेवायला, To-do List Apps मध्ये Tasks ठेवायला – अशा अनेक ठिकाणी List चा उपयोग होतो.

या Article मध्ये तुम्हाला काय शिकायला मिळणार आहे? आपण सुरुवातीपासून म्हणजे List म्हणजे काय इथपासून सुरुवात करून, List चे Features, Syntax, सगळे Methods, Operations, List Comprehension, List आणि Tuple मधील फरक, Common Mistakes, Best Practices आणि शेवटी Interview Questions पर्यंत सगळं शिकणार आहोत. चला तर मग सुरुवात करूया.

Python शिकताना सुरुवातीला आपण एक value एका variable मध्ये ठेवतो.

name = "Rupesh"
age = 25
city = "Pune"

हे छोटे programs लिहिताना ठीक आहे. पण समजा आपल्याला 100 विद्यार्थ्यांची नावे ठेवायची आहेत.

student1 = "Amit"
student2 = "Rahul"
student3 = "Sneha"
student4 = "Priya"

100 students साठी अशी variables तयार करणे practical नाही. इथे Python List कामाला येते.

students = ["Amit", "Rahul", "Sneha", "Priya"]

आता एकाच variable मध्ये अनेक values व्यवस्थित ठेवता येतात. पण Python List म्हणजे फक्त अनेक values एकत्र ठेवण्याची जागा नाही.

Program मध्ये data store करणे, शोधणे, बदलणे, filter करणे, sort करणे, process करणे आणि दुसऱ्या data structures सोबत वापरणे यासाठी List खूप उपयोगी पडते.

Python च्या documentation मध्ये List ला mutable sequence म्हणून हाताळले जाते. म्हणजे List तयार झाल्यानंतर तिच्यातील elements बदलता येतात आणि append(), extend(), insert(), remove(), pop(), sort() यांसारख्या operations करता येतात.

या लेखात आपण Python List फक्त syntax म्हणून शिकणार नाही.

What is Python List?

Python List म्हणजे Python मधील एक Built-in Data Structure आहे, जी Multiple Items एकाच Variable मध्ये Store करण्यासाठी वापरली जाते. List मधील प्रत्येक Item ला “Element” असं म्हणतात आणि हे सगळे Elements Square Brackets [ ] मध्ये आणि Comma ने Separate करून लिहिले जातात.

fruits = ["Apple", "Banana", "Mango"]
print(fruits)

Output: [‘Apple’, ‘Banana’, ‘Mango’]

या List मध्ये तीन elements आहेत:

Apple
Banana
Mango

Real-life Example: समजा तुम्ही Grocery Store मध्ये गेला आहात आणि तुमच्याकडे एक Shopping List आहे – दूध, ब्रेड, अंडी, साखर. ही Real Life मधील List प्रमाणेच Python List काम करते. एका ठिकाणी सगळ्या वस्तूंची नोंद, आणि गरज पडेल तेव्हा त्यात वस्तू Add किंवा Remove करता येतात.

Why Python List is important?

List मुळे आपल्याला वेगवेगळे Variables तयार करण्याची गरज पडत नाही. समजा १०० Students चे Marks ठेवायचे असतील, तर १०० Variables बनवण्याऐवजी एकच List वापरून काम होतं. यामुळे Code Clean, Short आणि Manage करायला सोपा होतो.

Advantages:

• एकाच Variable मध्ये Multiple Values Store करता येतात
• Data Type Flexible असतो (Numbers, Strings, अगदी दुसरी List सुद्धा ठेवता येते)
• Elements Add, Remove, Update करणं सोपं असतं
• Built-in Methods मुळे Data वर वेगवेगळ्या Operations पटकन करता येतात
• Real-world Data Handle करण्यासाठी सर्वात Flexible Structure आहे

Important Note: Python मध्ये List ही Mutable असते, म्हणजेच ती तयार झाल्यानंतर सुद्धा तिच्यात बदल करता येतात. हे एक महत्त्वाचं Feature आहे जे पुढे आपण सविस्तर बघणार आहोत.

List चा खरा उपयोग कुठे होतो?

List चा उपयोग फक्त fruits किंवा students ची उदाहरणे देण्यासाठी होत नाही. Real application मध्ये अनेक प्रकारचा data List मध्ये असू शकतो.

Shopping Cart

cart = ["Laptop", "Mouse", "Keyboard"]

Student Marks

marks = [78, 91, 65, 84, 72]

Website वरचे users

users = ["Amit", "Sneha", "Rahul"]

Tasks

tasks = [
    "Learn Python",
    "Practice Lists",
    "Build Project"
]

API मधून आलेला data

users = [
    {"name": "Amit", "age": 22},
    {"name": "Sneha", "age": 24}
]

इथे बाहेरची List अनेक users ठेवते आणि प्रत्येक user चा data Dictionary मध्ये आहे. हा pattern web development, APIs आणि database applications मध्ये वारंवार दिसतो.

Empty List कशी तयार करायची?

कधी कधी सुरुवातीला List रिकामी असते आणि program चालू असताना data add होतो.

tasks = []

tasks.append("Learn Python")
tasks.append("Practice")
tasks.append("Build Project")

print(tasks)

Output:

['Learn Python', 'Practice', 'Build Project']

हा pattern user input, API data processing किंवा dynamic application logic मध्ये सामान्य आहे.

List मधील Indexing समजून घ्या

Python मध्ये indexing 0 पासून सुरू होते.

languages = ["Python", "Java", "JavaScript", "Go"]

Index:

Python      → 0
Java        → 1
JavaScript  → 2
Go          → 3

म्हणून:

print(languages[0])
print(languages[2])

Output:

Python
JavaScript

Beginner ची common mistake

languages[1]

याचा अर्थ पहिला element नाही. तो दुसरा element आहे.

Negative Indexing

List च्या शेवटाकडून element access करायचा असेल तर negative indexing वापरता येते.

languages = ["Python", "Java", "JavaScript", "Go"]

print(languages[-1])
print(languages[-2])

Output:

Go
JavaScript

इथे:

-1 → शेवटचा element
-2 → शेवटच्या आधीचा element

List किती मोठी आहे हे माहीत नसतानाही शेवटचा element सहज मिळवता येतो.

List मधील Value बदलणे

List mutable असल्यामुळे index वापरून element बदलता येतो.

prices = [100, 200, 300]

prices[1] = 250

print(prices)

Output:

[100, 250, 300]

हे shopping cart, configuration values किंवा temporary application data मध्ये उपयोगी ठरू शकते.

List Slicing म्हणजे काय?

पूर्ण List ऐवजी तिच्यातील काही भाग हवा असेल तर slicing वापरता येते.

Syntax:

list[start:stop]

उदाहरण:

numbers = [10, 20, 30, 40, 50, 60]

print(numbers[1:4])

Output:

[20, 30, 40]

इथे:

start = 1
stop  = 4

पण index 4 result मध्ये येत नाही.

लक्षात ठेवा: Start included, stop excluded.

सुरुवातीपासून काही elements

numbers = [10, 20, 30, 40, 50]

print(numbers[:3])

Output:

[10, 20, 30]

शेवटापासून काही elements

print(numbers[2:])

Output:

[30, 40, 50]

Step वापरणे

numbers = [10, 20, 30, 40, 50, 60]

print(numbers[::2])

Output:

[10, 30, 50]

इथे प्रत्येक दुसरा element घेतला जातो.

List मध्ये Data Add करणे

List मध्ये data add करण्यासाठी तीन methods विशेषतः लक्षात ठेवा:

append()
extend()
insert()

पण तिन्ही एकसारखे नाहीत.

append() — शेवटी एक Element Add

fruits = ["Apple", "Banana"]

fruits.append("Mango")

print(fruits)

Output:

['Apple', 'Banana', 'Mango']

append() एक item List च्या शेवटी add करतो.

Practical Example

cart = []

cart.append("Laptop")
cart.append("Mouse")
cart.append("Keyboard")

आता:

print(cart)

Output:

['Laptop', 'Mouse', 'Keyboard']

append() मध्ये एक महत्त्वाची गोष्ट

समजा:

numbers = [1, 2, 3]

numbers.append([4, 5])

print(numbers)

Output:

[1, 2, 3, [4, 5]]

इथे [4, 5] एकच element म्हणून add झाले. जर तुम्हाला 4 आणि 5 स्वतंत्र elements म्हणून add करायचे असतील तर extend() वापरा.

extend() — अनेक Elements Add करणे

numbers = [1, 2, 3]

numbers.extend([4, 5])

print(numbers)

Output:

[1, 2, 3, 4, 5]

extend() iterable मधील elements एकामागोमाग List मध्ये जोडतो.

लक्षात ठेवण्याची सोपी पद्धत

append() → एक item
extend() → अनेक items

हा छोटा फरक real code मध्ये खूप महत्त्वाचा आहे.

insert() — Specific Position वर Element

समजा List:

fruits = ["Apple", "Mango"]

आणि "Banana" दुसऱ्या position वर पाहिजे.

fruits.insert(1, "Banana")

print(fruits)

Output:

['Apple', 'Banana', 'Mango']

Syntax:

list.insert(index, value)

List मधून Data Remove करणे

मुख्य methods:

remove()
pop()
clear()

यांचे काम वेगळे आहे.

remove() — Value माहीत असेल तर

fruits = ["Apple", "Banana", "Mango"]

fruits.remove("Banana")

print(fruits)

Output:

['Apple', 'Mango']

remove() दिलेल्या value ची पहिली matching occurrence काढतो. Value सापडली नाही तर ValueError येतो. म्हणून external/user data असल्यास:

if "Banana" in fruits:
    fruits.remove("Banana")

अशी check करणे उपयोगी ठरू शकते.

pop() — Index वरून Remove आणि Value मिळवा

pop() चे महत्त्वाचे वैशिष्ट्य म्हणजे तो remove केलेला element return करतो.

fruits = ["Apple", "Banana", "Mango"]

item = fruits.pop()

print(item)
print(fruits)

Output:

Mango
['Apple', 'Banana']

Specific index:

item = fruits.pop(0)

remove() vs pop()

remove(value)
→ value माहित आहे
→ value remove करायची

pop(index)
→ position माहित आहे
→ item remove करून तो item परत हवा

clear() — पूर्ण List रिकामी करणे

tasks = ["Study", "Practice", "Project"]

tasks.clear()

print(tasks)

Output:

[]

count() आणि index()

हे दोन methods अनेक tutorials मध्ये दुर्लक्षित केले जातात, पण practical code मध्ये उपयोगी आहेत.

count()

Value किती वेळा आली ते सांगतो.

numbers = [10, 20, 10, 30, 10]

print(numbers.count(10))

Output:

3

index()

Value पहिल्यांदा कोणत्या index वर आली ते सांगतो.

numbers = [10, 20, 30, 20]

print(numbers.index(20))

Output:

1

index() ला value न सापडल्यास ValueError येऊ शकतो. Python documentation मध्ये count() आणि index() हे List चे built-in methods म्हणून दिले आहेत.

List मध्ये Value आहे का?

fruits = ["Apple", "Banana", "Mango"]

if "Mango" in fruits:
    print("Mango available")

in membership checking साठी उपयोगी आहे.

Real Example

allowed_roles = ["admin", "editor", "author"]

role = "editor"

if role in allowed_roles:
    print("Access allowed")
else:
    print("Access denied")

हीच कल्पना मोठ्या application मध्ये permissions किंवा validation logic मध्ये दिसू शकते.

List वर Loop

List मधील प्रत्येक element process करण्यासाठी for loop वापरता येतो.

students = ["Amit", "Sneha", "Rahul"]

for student in students:
    print(student)

Output:

Amit
Sneha
Rahul

Marks process करणे

marks = [78, 35, 91, 42]

for mark in marks:
    if mark >= 40:
        print(mark, "Pass")
    else:
        print(mark, "Fail")

इथे List फक्त data ठेवत नाही. ती loop सोबत मिळून data processing करण्याचा भाग बनते.

enumerate() — Index आणि Value दोन्ही

कधी value सोबत तिचा index सुद्धा हवा असतो. अशावेळी manually:

for i in range(len(students)):
    print(i, students[i])

असे करण्याऐवजी:

for index, student in enumerate(students):
    print(index, student)

Output:

0 Amit
1 Sneha
2 Rahul

यामुळे code अधिक स्पष्ट होतो.

दोन Lists एकत्र process करणे — zip()

समजा:

names = ["Amit", "Sneha", "Rahul"]
marks = [78, 92, 85]

दोन्ही lists एकत्र process करायच्या आहेत.

for name, mark in zip(names, marks):
    print(name, mark)

Output:

Amit 78
Sneha 92
Rahul 85

हा pattern CSV data, reports आणि parallel collections process करताना उपयोगी ठरतो.

List मधील Numbers वर Built-in Functions

Python मध्ये List वर काही built-in functions सहज वापरता येतात.

marks = [78, 91, 65, 84, 72]

print(len(marks))
print(sum(marks))
print(min(marks))
print(max(marks))

Output:

5
390
65
91

Average:

average = sum(marks) / len(marks)

print(average)

यातून List आणि Python built-in functions यांचा एकत्र उपयोग समजतो.

sort() म्हणजे काय?

numbers = [40, 10, 30, 20]

numbers.sort()

print(numbers)

Output:

[10, 20, 30, 40]

Descending:

numbers.sort(reverse=True)

महत्त्वाची गोष्ट:

sort() original List मध्येच बदल करतो.

sort() vs sorted()

हा difference नीट समजून घेणे महत्त्वाचे आहे.

sort()

numbers = [30, 10, 20]

numbers.sort()

print(numbers)

Original List बदलते.

sorted()

numbers = [30, 10, 20]

result = sorted(numbers)

print(result)
print(numbers)

Output:

[10, 20, 30]
[30, 10, 20]

sorted() नवीन sorted result देते आणि source List तशीच राहते. Python documentation मध्ये हा फरक स्पष्ट केला आहे.

key वापरून Sorting

Real application मध्ये numbers किंवा simple strings sort करणे पुरेसे नसते.

समजा:

students = [
    {"name": "Amit", "marks": 78},
    {"name": "Sneha", "marks": 92},
    {"name": "Rahul", "marks": 85}
]

Marks नुसार sort करायचे असल्यास:

students.sort(key=lambda student: student["marks"])

High marks first:

students.sort(
    key=lambda student: student["marks"],
    reverse=True
)

इथे आपण List मधील प्रत्येक Dictionary मधील specific field वर sorting करत आहोत. हा pattern real-world data processing मध्ये List च्या basic examples पेक्षा जास्त उपयोगी आहे.

List Reverse करणे

numbers = [10, 20, 30, 40]

numbers.reverse()

print(numbers)

Output:

[40, 30, 20, 10]

reverse() फक्त order उलटा करतो. तो sorting करत नाही. reverse() हा List वर in-place बदल करणारा method आहे.

List Copy — इथे Beginners अडकतात

हा Python मधील खूप महत्त्वाचा concept आहे.

समजा:

original = [10, 20, 30]

new_list = original

new_list.append(40)

print(original)

Output:

[10, 20, 30, 40]

“मी new_list बदलली, मग original का बदलली?”

कारण:

new_list = original

यामुळे List ची नवीन copy तयार होत नाही. दोन्ही variables त्याच object कडे refer करतात. Python documentation नुसार assignment object ची copy करत नाही; ते target आणि object मधील binding तयार करते.

copy() वापरून Independent List

original = [10, 20, 30]

new_list = original.copy()

new_list.append(40)

print(original)
print(new_list)

Output:

[10, 20, 30]
[10, 20, 30, 40]

आता दोन्ही Lists स्वतंत्र आहेत.

Shallow Copy म्हणजे काय?

इथे थोडं पुढचं पण महत्त्वाचं concept येतं.

समजा:

users = [
    ["Amit", 22],
    ["Sneha", 24]
]

new_users = users.copy()

Outer List ची copy तयार झाली. पण आतल्या nested Lists च्या references तशाच राहू शकतात.

new_users[0][1] = 25

print(users)

यामुळे original मधील nested data देखील बदललेला दिसू शकतो. कारण copy() ही shallow copy आहे. Python च्या copy documentation नुसार shallow copy नवीन outer compound object तयार करते, पण त्यातील nested objects चे references ठेवते.

Deep Copy म्हणजे काय?

Nested objects पूर्णपणे independent हवेत तर deepcopy() वापरता येतो.

from copy import deepcopy

users = [
    ["Amit", 22],
    ["Sneha", 24]
]

new_users = deepcopy(users)

new_users[0][1] = 25

print(users)
print(new_users)

आता nested data देखील स्वतंत्र copy मध्ये असतो. पण deepcopy() प्रत्येक वेळी वापरायचा असा नियम नाही. तो कधी आवश्यक आहे हे data structure आणि mutation behavior समजून ठरवणे महत्त्वाचे आहे.

List Comprehension — फक्त Short Code नाही

List Comprehension हा Python मधील खूप उपयोगी feature आहे. समजा 1 ते 5 numbers चे squares तयार करायचे आहेत.

Normal loop:

squares = []

for number in range(1, 6):
    squares.append(number * number)

List Comprehension:

squares = [number * number for number in range(1, 6)]

दोन्हींचा result:

[1, 4, 9, 16, 25]

Python documentation नुसार List Comprehension चा उपयोग existing iterable मधून operation करून नवीन List तयार करण्यासाठी किंवा condition पूर्ण करणारे elements filter करण्यासाठी केला जातो.

Filtering with List Comprehension

marks = [35, 78, 42, 29, 91, 64]

passed = [
    mark for mark in marks
    if mark >= 40
]

print(passed)

Output:

[78, 42, 91, 64]

इथे:

Input
  ↓
प्रत्येक mark तपासा
  ↓
40 किंवा त्यापेक्षा जास्त?
  ↓
हो → नवीन List मध्ये

हा pattern data filtering मध्ये खूप उपयोगी आहे.

Data Transform करणे

समजा:

names = ["amit", "sneha", "rahul"]

सर्व names uppercase मध्ये हवे:

upper_names = [name.upper() for name in names]

print(upper_names)

Output:

['AMIT', 'SNEHA', 'RAHUL']

इथे आपण data filter केलेला नाही. आपण प्रत्येक element transform केला.

Filtering आणि Transformation एकत्र

prices = [100, 250, 50, 400, 80]

expensive = [
    price * 1.18
    for price in prices
    if price >= 100
]

print(expensive)

इथे:

1. price तपासली
2. condition लागू केली
3. योग्य values घेतल्या
4. त्यावर calculation केले
5. नवीन List तयार केली

यामुळे List Comprehension चा actual उपयोग समजतो.

List Comprehension किती मोठी करावी?

हा एक practical programming rule आहे.

हे:

result = [
    transform(x)
    for x in data
    if condition(x)
]

समजायला सोपे आहे.

पण जर:

result = [
    complex_function(x)
    for x in data
    if condition_one(x)
    and condition_two(x)
    and condition_three(x)
]

असे code वाचणे अवघड होत असेल तर normal for loop चांगला पर्याय असू शकतो. Shorter code म्हणजे नेहमी better code नाही. Readable code जास्त महत्त्वाचा असतो.

List बदलत असताना त्याच List वर Loop करणे

ही एक subtle mistake आहे.

उदाहरणार्थ:

numbers = [1, 2, 3, 4, 5, 6]

for number in numbers:
    if number % 2 == 0:
        numbers.remove(number)

अशा प्रकारे List iterate करताना त्याच List मध्ये remove/add केल्यामुळे अपेक्षित result मिळेलच असे नाही.

Python documentation देखील loop चालू असताना List बदलण्याऐवजी नवीन List तयार करणे अधिक सुरक्षित आणि स्पष्ट असू शकते असे दाखवते.

उदाहरण:

numbers = [1, 2, 3, 4, 5, 6]

odd_numbers = [
    number for number in numbers
    if number % 2 != 0
]

print(odd_numbers)

Output:

[1, 3, 5]

Nested List

एका List मध्ये दुसरी List ठेवली तर Nested List तयार होते.

students = [
    ["Amit", 85],
    ["Sneha", 92],
    ["Rahul", 78]
]

Access:

print(students[0])

Output:

['Amit', 85]

Specific value:

print(students[0][0])

Output:

Amit

Marks:

print(students[0][1])

Output:

85

पण Nested List प्रत्येक वेळी योग्य आहे का?

समजा user data असा आहे:

users = [
    ["Amit", 22, "Pune"],
    ["Sneha", 24, "Mumbai"]
]

इथे:

index 0 → name
index 1 → age
index 2 → city

हा data मोठा झाला की code वाचणे कठीण होऊ शकते.

त्याऐवजी:

users = [
    {
        "name": "Amit",
        "age": 22,
        "city": "Pune"
    },
    {
        "name": "Sneha",
        "age": 24,
        "city": "Mumbai"
    }
]

असे केल्यास प्रत्येक field ला नाव मिळते. म्हणून List समजणे म्हणजे प्रत्येक data साठी List वापरणे नव्हे; योग्य data structure निवडणेही तितकेच महत्त्वाचे आहे.

List vs Tuple vs Set vs Dictionary

उदाहरण

shopping_cart = ["Laptop", "Mouse"]

→ List

coordinates = (18.52, 73.85)

→ Tuple

unique_tags = {"python", "django", "api"}

→ Set

user = {
    "name": "Amit",
    "age": 25
}

→ Dictionary Data structure निवडताना “काय syntax आहे?” पेक्षा:

“माझ्या data ची गरज काय आहे?” हा प्रश्न विचारणे जास्त महत्त्वाचे आहे.

List ला Queue म्हणून वापरावे का?

List ला Stack म्हणून वापरणे योग्य आहे.

stack = []

stack.append("A")
stack.append("B")
stack.append("C")

print(stack.pop())

Output:

C

म्हणजे:

Last In → First Out

पण List ला मोठ्या queue साठी वापरणे योग्य नाही.

queue.pop(0)

अशा operation मध्ये सुरुवातीचे elements shift करावे लागू शकतात.

Python documentation नुसार queue साठी collections.deque अधिक योग्य आहे कारण दोन्ही ends वर efficient append/pop operations मिळतात.

उदाहरण:

from collections import deque

queue = deque()

queue.append("A")
queue.append("B")
queue.append("C")

print(queue.popleft())

Output:

A

हा छोटासा फरक developer म्हणून data structure निवडताना उपयोगी पडतो.

List ची Performance समजून घेणे

प्रत्येक operation ची किंमत सारखी नसते.

उदाहरणार्थ:

numbers.append(100)

शेवटी element add करणे List च्या सामान्य use-case मध्ये efficient आहे.

पण:

numbers.insert(0, 100)

किंवा:

numbers.pop(0)

यात सुरुवातीपासून elements shift होऊ शकतात. म्हणून जर program मध्ये सतत सुरुवातीला data add/remove करायचा असेल तर deque सारखा data structure विचारात घ्या. Python documentation देखील List च्या front operations च्या performance बद्दल हीच सूचना देते.

Real-World Example — API मधून आलेला User Data

समजा API कडून आपल्याला असा data मिळाला:

users = [
    {"name": "Amit", "active": True},
    {"name": "Sneha", "active": False},
    {"name": "Rahul", "active": True},
    {"name": "Priya", "active": True}
]

फक्त active users हवेत:

active_users = [
    user for user in users
    if user["active"]
]

नावे हवी असतील:

active_names = [
    user["name"]
    for user in users
    if user["active"]
]

Output:

['Amit', 'Rahul', 'Priya']

इथे List + Dictionary + condition + comprehension एकत्र वापरले आहेत. अशा प्रकारचा code real projects मध्ये basic fruits = ["Apple"] example पेक्षा जास्त महत्त्वाचा ठरतो.

Real-World Example — Product Filtering

products = [
    {"name": "Laptop", "price": 60000},
    {"name": "Mouse", "price": 800},
    {"name": "Keyboard", "price": 1500},
    {"name": "Monitor", "price": 12000}
]

₹10,000 पेक्षा जास्त किंमतीची products:

expensive_products = [
    product
    for product in products
    if product["price"] > 10000
]

फक्त names:

product_names = [
    product["name"]
    for product in products
    if product["price"] > 10000
]

Output:

['Laptop', 'Monitor']

हीच logic e-commerce website मध्ये product filtering सारख्या कामांसाठी वापरता येते.

Real-World Example — Database Data Process करणे

Database query केल्यानंतर application ला records मिळू शकतात.

उदाहरण:

users = [
    {"id": 1, "name": "Amit", "age": 21},
    {"id": 2, "name": "Sneha", "age": 25},
    {"id": 3, "name": "Rahul", "age": 19}
]

18 पेक्षा मोठे users:

adult_users = [
    user
    for user in users
    if user["age"] >= 18
]

Names:

names = [user["name"] for user in adult_users]

यातून एक महत्त्वाची गोष्ट समजते:

List हा database नाही.

Database data retrieve केल्यानंतर application level वर तो data process करण्यासाठी List उपयोगी पडू शकते.

List मधून Duplicate Data काढणे

समजा:

numbers = [10, 20, 10, 30, 20, 40]

Uniqueness हवी असल्यास:

unique_numbers = list(set(numbers))

पण Set वापरल्यावर List चा original order जपण्याची अपेक्षा करू नका.

जर order जपायचा असेल:

numbers = [10, 20, 10, 30, 20, 40]

unique_numbers = []

for number in numbers:
    if number not in unique_numbers:
        unique_numbers.append(number)

print(unique_numbers)

Output:

[10, 20, 30, 40]

मोठ्या data वर uniqueness checking वारंवार करायची असल्यास Set चा वापर करून design सुधारता येऊ शकते.

List मधील Common Mistakes

Mistake 1 — Index 0 पासून सुरू होतो हे विसरणे

students[1]

हा दुसरा element आहे.

Mistake 2 — append() आणि extend() गोंधळणे

items.append([3, 4])

आणि:

items.extend([3, 4])

दोन्हीचा result वेगळा आहे.

Mistake 3 — remove() ला चुकीची value देणे

items.remove("Laptop")

Laptop नसेल तर error येऊ शकतो.

Mistake 4 — sort() चा return value वापरणे

चुकीचा pattern:

result = numbers.sort()

sort() List बदलतो; sorted List return करण्यासाठी sorted() वापरा.

Mistake 5 — List copy करण्यासाठी =

new_list = old_list

ही independent copy नाही.

Mistake 6 — Loop चालू असताना List modify करणे

यामुळे elements skip होण्यासारखे unexpected results मिळू शकतात. नवीन List तयार करणे किंवा वेगळ्या approach ने filtering करणे अधिक सुरक्षित असते.

List समजली आहे की नाही हे कसे तपासाल?

खालील code पाहा:

numbers = [10, 20, 30]

a = numbers
b = numbers.copy()

a.append(40)
b.append(50)

print(numbers)
print(a)
print(b)

Output काय येईल? स्वतः आधी विचार करा.

उत्तर:

[10, 20, 30, 40]
[10, 20, 30, 40]
[10, 20, 30, 50]

का?

कारण:

a = numbers

मुळे a आणि numbers एकाच List object कडे refer करतात.

तर:

b = numbers.copy()

मुळे स्वतंत्र outer List तयार होते.

अशा प्रश्नांमधून syntax पेक्षा Python objects कसे behave करतात हे समजते.

List शिकण्यासाठी Practical Project

फक्त examples run करण्यापेक्षा छोटा project बनवा.

Student Marks Manager

Program मध्ये:

1. Student add करा
2. Marks add करा
3. सर्व students दाखवा
4. Highest marks शोधा
5. Lowest marks शोधा
6. Passed students दाखवा
7. Failed students दाखवा
8. Marks sort करा
9. Student remove करा
10. Program बंद करा

उदाहरण data:

students = [
    {"name": "Amit", "marks": 78},
    {"name": "Sneha", "marks": 92},
    {"name": "Rahul", "marks": 35}
]

यानंतर:

• List
• Dictionary
• Loop
• Condition
• Functions
• Input
• Sorting
• Filtering

हे सगळे एकत्र वापरता येतील. अशा project मधून List खरोखर समजते.

Python List Interview Questions

List शिकून झाल्यावर खालील प्रश्न स्वतः code करून सोडवा.

Basic

1. Python List म्हणजे काय?
2. List mutable का म्हणतात?
3. List indexing 0 पासून का सुरू होते?
4. Negative indexing म्हणजे काय?
5. List मध्ये duplicate values ठेवता येतात का?

Methods

6. append() आणि extend() मध्ये फरक?
7. remove() आणि pop() मध्ये फरक?
8. sort() आणि sorted() मध्ये फरक?
9. clear() काय करते?
10. count() आणि index() कशासाठी?

Practical

11. List मधील duplicate values कशा काढाल?
12. List मधील second largest number कसा शोधाल?
13. List मधील even numbers कसे मिळवाल?
14. दोन Lists कशा combine कराल?
15. दोन Lists मधील common values कशा शोधाल?

Python internals

16. a = b आणि a = b.copy() मध्ये फरक?
17. Shallow copy म्हणजे काय?
18. Deep copy कधी आवश्यक असते?
19. Nested List म्हणजे काय?
20. List ला queue म्हणून वापरणे कधी योग्य नाही?

FAQs Python List

Blogger Rupesh

माझं नाव रुपेश आहे, आणि मी एक Blogger तसेच Content Writer आहे. मी माझा ब्लॉगिंगचा प्रवास वयाच्या ३० व्या वर्षी सुरू केला आणि आज मला या क्षेत्रात ५ वर्षांचा अनुभव आहे.माझा ब्लॉग “Learn Grow” मराठी भाषेत असून, त्यावर मी Blogging, Education, Programming शिकणे आणि AI Tools यांसारख्या महत्त्वाच्या विषयांवर सोप्या आणि समजण्यासारख्या भाषेत माहिती शेअर करतो. यासोबतच, मी Freelancing Services देखील प्रदान करतो, ज्यामध्ये Content Writing, SEO आणि Digital Marketing संबंधित कामांचा समावेश आहे.