📦 آموزش کامل لیست‌ها در پایتون (Lists)

🔰 لیست در پایتون چیست؟

لیست (List) یکی از پرکاربردترین ساختارهای داده در پایتون است. یک لیست مانند یک جعبه بزرگ است که می‌توانید هر چیزی را داخل آن بگذارید: اعداد، رشته‌ها، مقادیر درست/غلط، و حتی لیست‌های دیگر!

📝 روش‌های ایجاد لیست

🔹 روش اول: استفاده از براکت []

ساده‌ترین راه. عناصر را داخل [] قرار می‌دهیم و با کاما جدا می‌کنیم.

a = [1, 2, 3, 4, 5]
b = ['apple', 'banana', 'cherry']
c = [1, 'hello', 3.14, True]
print(a)
print(b)
print(c)

🔹 روش دوم: استفاده از سازنده list()

با تابع list() می‌توان از هر چیزی که «قابل پیمایش» است (مثل رشته، تاپل، محدوده اعداد) یک لیست ساخت.

a = list((1, 2, 3))   # از تاپل
b = list('Python')      # از رشته
c = list(range(5))      # از محدوده اعداد 0 تا 4
print(a)
print(b)
print(c)

🔹 روش سوم: ایجاد لیست با عناصر تکراری

با استفاده از عملگر * می‌توان یک لیست را چند بار تکرار کرد.

a = [2] * 5   # [2, 2, 2, 2, 2]
b = [0] * 7   # [0, 0, 0, 0, 0, 0, 0]
print(a)
print(b)

🎯 دسترسی به عناصر لیست

🔹 اندیس‌گذاری مثبت (از 0 تا n-1)

اولین عنصر اندیس 0 دارد، دومین عنصر اندیس 1 و آخرین عنصر اندیس n-1 (که n طول لیست است).

a = [10, 20, 30, 40, 50]
print(a[0])   # 10 (اولین)
print(a[2])   # 30 (سومین)
print(a[4])   # 50 (آخرین)

🔹 اندیس‌گذاری منفی (از انتها)

با اندیس‌های منفی می‌توان از انتهای لیست به عناصر دسترسی پیدا کرد. -1 آخرین عنصر، -2 یکی مانده به آخر و ... است.

a = [10, 20, 30, 40, 50]
print(a[-1])   # 50 (آخرین)
print(a[-2])   # 40 (یکی مانده به آخر)
print(a[-5])   # 10 (اولین)

🔹 برش (Slicing) — استخراج بخشی از لیست

با برش می‌توانید بخشی از یک لیست را استخراج کنید. فرمت: [start:end:step]

a = [10, 20, 30, 40, 50]
print(a[1:4])    # [20, 30, 40] (از اندیس 1 تا قبل از 4)
print(a[:3])     # [10, 20, 30] (از ابتدا تا قبل از 3)
print(a[2:])     # [30, 40, 50] (از اندیس 2 تا انتها)
print(a[::2])    # [10, 30, 50] (قدم 2)
print(a[::-1])   # [50, 40, 30, 20, 10] (برعکس)

➕ افزودن عناصر به لیست

🔹 append(x) — اضافه کردن به انتها

یک عنصر را به آخر لیست اضافه می‌کند.

a = [1, 2, 3]
a.append(4)
print(a)  # [1, 2, 3, 4]

🔹 insert(i, x) — درج در موقعیت مشخص

عنصر x را در اندیس i قرار می‌دهد. عناصر بعدی به سمت راست حرکت می‌کنند.

a = [1, 2, 3]
a.insert(1, 99)
print(a)  # [1, 99, 2, 3]

🔹 extend(iterable) — اضافه کردن چند عنصر

همه عناصر یک تکرارپذیر (مثل لیست دیگر) را به انتهای لیست اضافه می‌کند.

a = [1, 2, 3]
a.extend([4, 5, 6])
print(a)  # [1, 2, 3, 4, 5, 6]

✏️ به‌روزرسانی عناصر لیست

لیست‌ها تغییرپذیرند، بنابراین می‌توان مقدار یک عنصر را با اندیس آن تغییر داد.

a = [10, 20, 30, 40]
a[1] = 25
print(a)  # [10, 25, 30, 40]

❌ حذف عناصر از لیست

🔹 remove(x) — حذف با مقدار

اولین رخداد مقدار x را حذف می‌کند. اگر مقدار وجود نداشته باشد، خطا می‌دهد.

a = [10, 20, 30, 20]
a.remove(20)
print(a)  # [10, 30, 20]

🔹 pop(i) — حذف با اندیس و دریافت مقدار

عنصر در اندیس i را حذف کرده و آن را برمی‌گرداند. اگر اندیس ندهیم، آخرین عنصر را حذف می‌کند.

a = [10, 20, 30, 40]
val = a.pop(1)
print(val)   # 20
print(a)     # [10, 30, 40]

🔹 del — حذف با اندیس یا حذف کل لیست

a = [10, 20, 30, 40]
del a[0]
print(a)  # [20, 30, 40]

🔄 پیمایش لیست با حلقه for

حلقه `for` یکی از قدرتمندترین ابزارها در پایتون است. با استفاده از حلقه `for` می‌توانید روی همه عناصر یک لیست پیمایش کنید و برای هر عنصر یک کار مشخص انجام دهید. تصور کنید یک جعبه پر از میوه دارید و می‌خواهید هر میوه را جداگانه بررسی کنید — حلقه `for` دقیقاً همین کار را با لیست‌ها انجام می‌دهد.

🔹 روش اول: پیمایش مستقیم عناصر (ساده‌ترین)

در این روش، متغیر حلقه مستقیماً مقدار هر عنصر را می‌گیرد. اگر فقط به خود عناصر نیاز دارید و نیازی به شماره اندیس ندارید، این روش بهترین انتخاب است.

fruits = ['apple', 'banana', 'cherry', 'date']
for fruit in fruits:
    print(fruit)

خروجی:

apple
banana
cherry
date

scores = [18, 15, 19, 14, 17]
new_scores = []
for score in scores:
    new_scores.append(score + 2)
print(new_scores)  # [20, 17, 21, 16, 19]

🔹 روش دوم: پیمایش با دسترسی به ایندکس (با range و len)

گاهی نیاز داریم هم به اندیس (موقعیت) عنصر دسترسی داشته باشیم و هم به خود عنصر. مثلاً بخواهیم بدانیم کدام عنصر در کدام خانه لیست قرار دارد. در این روش از ترکیب range() و len() استفاده می‌کنیم.

fruits = ['apple', 'banana', 'cherry', 'date']
for i in range(len(fruits)):
    print(f'اندیس {i}: {fruits[i]}')

خروجی:

اندیس 0: apple
اندیس 1: banana
اندیس 2: cherry
اندیس 3: date

fruits = ['apple', 'banana', 'cherry', 'date']
for i in range(len(fruits)):
    if fruits[i] == 'cherry':
        print(f'cherry در اندیس {i} قرار دارد')

🔹 روش سوم: پیمایش با enumerate() (روش حرفه‌ای و خوانا)

تابع enumerate() بهترین و خواناترین روش برای پیمایش زمانی است که هم به اندیس و هم به مقدار نیاز دارید. این تابع برای هر عنصر لیست یک جفت (اندیس، مقدار) برمی‌گرداند.

fruits = ['apple', 'banana', 'cherry', 'date']
for index, fruit in enumerate(fruits):
    print(f'اندیس {index}: {fruit}')

خروجی: (همانند روش قبل)

fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits, start=1):
    print(f'{index}: {fruit}')

خروجی:

1: apple
2: banana
3: cherry

🔹 نکته مهم: تغییر عناصر لیست در حین پیمایش

اگر می‌خواهید عناصر لیست را در حین پیمایش تغییر دهید، باید از روش ایندکسی استفاده کنید (روش دوم یا سوم با اندیس). روش اول (پیمایش مستقیم) نمی‌تواند عناصر اصلی لیست را تغییر دهد.

numbers = [1, 2, 3, 4, 5]
for n in numbers:
    n = n * 2   # این فقط متغیر حلقه را تغییر می‌دهد، نه لیست اصلی
print(numbers)  # [1, 2, 3, 4, 5] (تغییر نکرده!)

numbers = [1, 2, 3, 4, 5]
for i in range(len(numbers)):
    numbers[i] = numbers[i] * 2
print(numbers)  # [2, 4, 6, 8, 10]

🔹 مقایسه روش‌های مختلف پیمایش لیست

🛠️ متدها و توابع مهم کار با لیست

در پایتون، توابع و متدهای آماده‌ای وجود دارند که کار با لیست‌ها را بسیار آسان می‌کنند. در این بخش هر کدام را با جزئیات کامل یاد می‌گیریم.

📌 1. تابع len() — محاسبه طول لیست

تابع len() تعداد عناصر موجود در یک لیست را برمی‌گرداند. این تابع برای هر نوع لیستی کار می‌کند.

a = [10, 20, 30, 40, 50]
b = ['apple', 'banana']
c = []
print(len(a))  # 5
print(len(b))  # 2
print(len(c))  # 0 (لیست خالی)

📌 2. تابع sum() — جمع عناصر لیست

تابع sum() مجموع همه عناصر عددی یک لیست را محاسبه می‌کند. این تابع فقط برای لیست‌هایی کار می‌کند که همه عناصرشان عدد باشند.

numbers = [10, 20, 30, 40, 50]
print(sum(numbers))  # 150
print(sum([1, 2, 3]))  # 6

# این کد خطا می‌دهد:
a = [1, 2, 'hello']
print(sum(a))  # TypeError!

📌 3. تابع min() — کوچکترین عنصر

تابع min() کوچکترین (کمینه) عنصر را در لیست پیدا می‌کند.

numbers = [50, 10, 40, 20, 30]
names = ['ali', 'reza', 'sara']
print(min(numbers))  # 10
print(min(names))    # 'ali' (بر اساس ترتیب حروف الفبا)

📌 4. تابع max() — بزرگترین عنصر

تابع max() بزرگترین (بیشینه) عنصر را در لیست پیدا می‌کند.

numbers = [50, 10, 40, 20, 30]
names = ['ali', 'reza', 'sara']
print(max(numbers))  # 50
print(max(names))    # 'sara' (بر اساس ترتیب حروف الفبا)

📌 5. متد sort() — مرتب‌سازی لیست (تغییر در خود لیست)

متد sort() عناصر لیست را به صورت صعودی (از کوچک به بزرگ) مرتب می‌کند. این متد خود لیست را تغییر می‌دهد و چیزی برنمی‌گرداند.

numbers = [3, 1, 4, 1, 5, 9, 2]
numbers.sort()
print(numbers)  # [1, 1, 2, 3, 4, 5, 9]

مرتب‌سازی نزولی (از بزرگ به کوچک):

numbers = [3, 1, 4, 1, 5]
numbers.sort(reverse=True)
print(numbers)  # [5, 4, 3, 1, 1]

📌 6. تابع sorted() — مرتب‌سازی بدون تغییر لیست اصلی

تابع sorted() مانند sort() عمل می‌کند، اما لیست اصلی را تغییر نمی‌دهد و یک لیست جدید مرتب شده برمی‌گرداند.

original = [3, 1, 4, 1, 5]
sorted_list = sorted(original)
print(sorted_list)  # [1, 1, 3, 4, 5]
print(original)     # [3, 1, 4, 1, 5] (تغییر نکرده)

📌 7. متد count() — شمارش تعداد یک مقدار

متد count() تعداد دفعات تکرار یک مقدار مشخص را در لیست شمارش می‌کند.

numbers = [1, 2, 3, 1, 1, 4, 1, 5]
print(numbers.count(1))  # 4 (چهار بار عدد 1 تکرار شده)
print(numbers.count(10)) # 0 (عدد 10 وجود ندارد)

📌 8. متد index() — پیدا کردن اندیس یک مقدار

متد index() اولین اندیسی که یک مقدار مشخص در آن قرار دارد را برمی‌گرداند. اگر مقدار پیدا نشود، خطا می‌دهد.

fruits = ['apple', 'banana', 'cherry', 'banana', 'date']
print(fruits.index('banana'))    # 1 (اولین banana در اندیس 1 است)
print(fruits.index('grape'))     # ValueError! (پیدا نشد)

📌 9. متد reverse() — برعکس کردن لیست

متد reverse() ترتیب عناصر لیست را برعکس می‌کند (آخرین عنصر می‌شود اولین). این متد خود لیست را تغییر می‌دهد.

numbers = [1, 2, 3, 4, 5]
numbers.reverse()
print(numbers)  # [5, 4, 3, 2, 1]

اگر می‌خواهید لیست اصلی تغییر نکند، از برش با [::-1] استفاده کنید:

numbers = [1, 2, 3, 4, 5]
reversed_list = numbers[::-1]
print(reversed_list)  # [5, 4, 3, 2, 1]
print(numbers)        # [1, 2, 3, 4, 5] (تغییر نکرده)

📌 10. متد copy() — کپی کردن لیست

متد copy() یک کپی سطحی (shallow copy) از لیست می‌سازد.

original = [1, 2, 3]
new_list = original.copy()
new_list.append(4)
print(original)  # [1, 2, 3] (تغییر نکرده)
print(new_list)  # [1, 2, 3, 4]

a = [1, 2, 3]
b = a          # این کپی نیست، هر دو به یک لیست اشاره دارند
b.append(4)
print(a)       # [1, 2, 3, 4] (a هم تغییر کرد!)

📌 11. متد clear() — خالی کردن لیست

متد clear() همه عناصر لیست را حذف می‌کند و لیست را خالی می‌کند.

numbers = [1, 2, 3, 4, 5]
numbers.clear()
print(numbers)  # []

📊 جدول جمع‌بندی متدها و توابع مهم

📦 لیست‌های تودرتو (Nested Lists)

لیست تودرتو یعنی لیستی که عناصر آن خود لیست هستند. مانند یک جدول یا ماتریس.

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print(matrix[0])     # [1, 2, 3]
print(matrix[1][2])  # 6

📌 نحوه ذخیره‌سازی مراجع در لیست

لیست‌ها مقادیر را مستقیماً ذخیره نمی‌کنند، بلکه مراجع (اشاره‌گر) به اشیاء در حافظه را ذخیره می‌کنند. به همین دلیل است که لیست می‌تواند انواع مختلف داده را کنار هم نگه دارد.

a = [10, 'hello', 3.14, True]
print(a[0])  # 10 (اشاره به عدد)
print(a[1])  # hello (اشاره به رشته)

❌ اشتباهات رایج هنگام کار با لیست‌ها

• IndexError: دسترسی به اندیس خارج از محدوده لیست.
• فراموشی اینکه اندیس از 0 شروع می‌شود: a[1] دومین عنصر است، نه اولین.
• استفاده از append به جای extend: a.append([4,5]) کل لیست را یک عضو اضافه می‌کند، اما a.extend([4,5]) اعضا را جدا اضافه می‌کند.
• تکثیر لیست‌های تودرتو با *: [[]] * 3 یک لیست با سه ارجاع به یک لیست داخلی می‌سازد.

a = [[0]] * 3   # این اشتباه است!
a[0][0] = 1
print(a)  # [[1], [1], [1]] (همه تغییر کردند!)

✍️ تمرینات پایانی

📌 جدول متدهای پرکاربرد لیست‌ها