در دنیای برنامه‌نویسی، جایی که داده‌ها مانند رودخانه‌ای جاری نقش کلیدی ایفا می‌کنند، ساختارهای داده‌ای مانند لیست‌ها در پایتون به عنوان یکی از بنیادی‌ترین ابزارها ظاهر می‌شوند. تصور کنید که در حال ساختن یک برنامه ساده برای مدیریت فهرست خرید هستید؛ لیست‌ها به شما اجازه می‌دهند تا اقلام را به راحتی اضافه، حذف یا تغییر دهید، بدون اینکه نگران محدودیت‌های سفت و سخت باشید.

پایتون، زبانی که بر سادگی و خوانایی تأکید دارد، لیست‌ها را به عنوان یک مجموعه مرتب و قابل تغییر (mutable) طراحی کرده است. این ویژگی نه تنها انعطاف‌پذیری بالایی فراهم می‌کند، بلکه آن‌ها را به گزینه‌ای ایده‌آل برای مبتدیان و متخصصان تبدیل می‌نماید. در این مقاله جامع، که بر اساس منابع معتبر مانند مستندات رسمی پایتون، GeeksforGeeks و Real Python تدوین شده، به بررسی همه‌جانبه لیست‌ها می‌پردازیم.

لیست چیست و چرا مهم است؟

لیست در پایتون یک مجموعه مرتب و تغییرپذیر (mutable) از عناصر است که می‌تواند انواع داده‌ای مختلف را در خود جای دهد. برخلاف آرایه‌های زبان‌هایی مانند C که نوع داده ثابت دارند، لیست‌های پایتون می‌توانند اعداد، رشته‌ها، بولین‌ها یا حتی لیست‌های دیگر را ذخیره کنند. این ویژگی، آن‌ها را به ابزاری همه‌کاره برای مدیریت داده‌ها تبدیل می‌کند. برای شروع، بیایید یک لیست ساده بسازیم:

خرید = [“سیب”, “موز”, 5, True]

print(خرید) # خروجی: [‘سیب’, ‘موز’, 5, True]

این کد یک لیست با چهار عنصر ایجاد می‌کند. برای اجرای آن، می‌توانید از محیط‌هایی مثل Python IDLE، VS Code یا Jupyter Notebook استفاده کنید. لیست‌ها با کروشه [] تعریف می‌شوند و عناصر با کاما جدا می‌گردند. یک لیست خالی هم به‌سادگی تعریف می‌شود:

لیست_خالی = []

print(لیست_خالی) # خروجی: []

انواع لیست‌ها: تنوع در کاربرد

هرچند پایتون “انواع” رسمی مختلفی برای لیست‌ها ندارد (همه لیست‌ها از نوع list هستند)، اما بر اساس محتوا و ساختار، می‌توان آن‌ها را دسته‌بندی کرد. این دسته‌بندی‌ها بیشتر برای درک بهتر کاربردها مفیدند و بر اساس منابع مانند W3Schools و GeeksforGeeks، به شرح زیر هستند:

لیست‌های همگن (Homogeneous Lists): شامل عناصری از یک نوع داده، مانند اعداد یا رشته‌ها. این نوع برای محاسبات عددی یا پردازش متن ایده‌آل است. مثلاً:

اعداد = [1, 2, 3, 4, 5]

print(اعداد) # خروجی: [1, 2, 3, 4, 5]

میوه‌ها = [“سیب”, “پرتقال”, “موز”]

print(میوه‌ها) # خروجی: [‘سیب’, ‘پرتقال’, ‘موز’]

این نوع برای محاسبات عددی یا پردازش متن مناسب است.

لیست‌های ناهمگن (Heterogeneous Lists): ترکیبی از انواع داده‌ها. این انعطاف، پایتون را از زبان‌های سفت‌وسخت متمایز می‌کند.

اطلاعات = [“علی”, 25, “تهران”, True]

print(اطلاعات) # خروجی: [‘علی’, 25, ‘تهران’, True]

این نوع برای ذخیره داده‌های ترکیبی مثل اطلاعات کاربر کاربرد دارد.

• لیست‌های تو در تو (Nested Lists): لیست‌هایی داخل لیست، شبیه ماتریس‌ها. این نوع برای ساختارهای دوبعدی مانند جدول‌ها یا گراف‌ها مفید است.

ماتریس = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

print(ماتریس[1][2]) # خروجی: 6 (سطر دوم، ستون سوم)

این نوع برای ساختارهای دوبعدی مثل بازی‌ها یا پردازش تصویر مفید است.

• لیست‌های خالی یا تک‌عنصری: برای شروع یا ذخیره موقت. مثال:

تک_عنصر = [42]

print(تک_عنصر) # خروجی: [42]

این دسته‌بندی‌ها ثابت نیستند؛ یک لیست می‌تواند در طول برنامه تغییر نوع دهد، زیرا mutable است. مثلاً از یک لیست همگن، عنصری ناهمگن اضافه کنید. نکته مهم: لیست‌ها مرجع (reference) به اشیاء ذخیره می‌کنند، نه خود اشیاء، که این موضوع در کپی‌برداری تأثیرگذار است.

دسترسی و تغییر عناصر: هسته اصلی لیست‌ها

دسترسی به عناصر لیست از طریق ایندکس (index) انجام می‌شود، که از 0 شروع می‌شود. ایندکس منفی هم برای شمارش از انتها وجود دارد (-1 برای آخرین عنصر). برش (slicing) اجازه می‌دهد محدوده‌ای را استخراج کنید: لیست[شروع:پایان:گام].

فرض کنید لیست رنگ‌ها = [“قرمز”, “سبز”, “آبی”, “زرد”]. دسترسی ساده:

رنگ‌ها = [“قرمز”, “سبز”, “آبی”, “زرد”]

print(رنگ‌ها[0]) # خروجی: قرمز

print(رنگ‌ها[-1]) # خروجی: زرد

print(رنگ‌ها[1:3]) # خروجی: [‘سبز’, ‘آبی’]

print(رنگ‌ها[::-1]) # خروجی: [‘زرد’, ‘آبی’, ‘سبز’, ‘قرمز’]

برای تغییر:

رنگ‌ها[2] = “بنفش”

print(رنگ‌ها) # خروجی: [‘قرمز’, ‘سبز’, ‘بنفش’, ‘زرد’]

اگر ایندکسی خارج از محدوده باشد، خطای IndexError رخ می‌دهد. برای جلوگیری، از len(رنگ‌ها) برای طول لیست استفاده کنید. برای بررسی عضویت:

if “قرمز” in رنگ‌ها:

print(“قرمز در لیست است”) # خروجی: قرمز در لیست است

متدهای لیست: ابزارهای تغییر و تحول

پایتون متدهای متعددی برای دستکاری لیست‌ها ارائه می‌دهد. همه این متدها درجا (in-place) عمل می‌کنند و لیست را تغییر می‌دهند. در ادامه، متدها با مثال‌های ساده:

• append(x): اضافه کردن x به انتهای لیست.

لیست = [1, 2]

لیست.append(3)

print(لیست) # خروجی: [1, 2, 3]

• extend(iterable): افزودن عناصر یک iterable به انتها.

لیست.extend([4, 5])

print(لیست) # خروجی: [1, 2, 3, 4, 5]

• insert(i, x): درج x در ایندکس i.

لیست.insert(1, 0)

print(لیست) # خروجی: [1, 0, 2, 3, 4, 5]

• remove(x): حذف اولین رخداد x.

لیست.remove(2)

print(لیست) # خروجی: [1, 0, 3, 4, 5]

• pop(i): حذف و بازگشت عنصر در i (پیش‌فرض: آخرین).

حذف_شده = لیست.pop()

print(حذف_شده, لیست) # خروجی: 5 [1, 0, 3, 4]

• ()clear : خالی کردن لیست.

لیست.clear()

print(لیست) # خروجی: []

• index(x): بازگشت ایندکس اولین x.

ایندکس = [1, 2, 3].index(2)

print(ایندکس) # خروجی: 1

• count(x): شمارش رخدادهای x.

شمارش = [1, 2, 2].count(2)

print(شمارش) # خروجی: 2

• sort(key=None, reverse=False): مرتب‌سازی درجا.

اعداد = [3, 1, 2]

اعداد.sort()

print(اعداد) # خروجی: [1, 2, 3]

• ()reverse: برعکس کردن لیست.

اعداد.reverse()

print(اعداد) # خروجی: [3, 2, 1]

• ()copy: کپی سطحی از لیست.

کپی = اعداد.copy()

print(کپی) # خروجی: [3, 2, 1]

توابع داخلی مثل ()len()، max() ، min و ()sum هم بسیار مفیدند:

print(sum([1, 2, 3])) # خروجی: 6

استفاده از لیست‌ها به‌عنوان پشته و صف

لیست‌ها می‌توانند به‌عنوان پشته (LIFO) عمل کنند. برای push از append و برای pop از pop استفاده کنید:

پشته = []

پشته.append(1)

پشته.append(2)

print(پشته.pop()) # خروجی: 2

برای صف (FIFO)، بهتر است از collections.deque استفاده کنید:

from collections import deque

صف = deque([1, 2])

صف.append(3)

اولین = صف.popleft()

print(اولین, صف) # خروجی: 1 deque([2, 3])

فهرست‌سازی (List Comprehension): کد کوتاه، نتیجه بزرگ

فهرست‌سازی راهی مختصر برای ساخت لیست است:

مربعات = [x**2 for x in range(10) if x % 2 == 0]

print(مربعات) # خروجی: [0, 4, 16, 36, 64]

برای لیست تو در تو:

ماتریس = [[j for j in range(3)] for i in range(3)]

print(ماتریس) # خروجی: [[0, 1, 2], [0, 1, 2], [0, 1, 2]]

پیمایش لیست‌ها: حلقه‌ها و enumerate

با حلقه for:

for رنگ in رنگ‌ها:

print(رنگ)

با enumerate برای ایندکس و مقدار:

for i, رنگ in enumerate(رنگ‌ها):

print(f”ایندکس {i}: {رنگ}”)

تفاوت لیست و تاپل: تغییرپذیر در برابر تغییرناپذیر

تاپل‌ها (تعریف با ()) شبیه لیست‌ها هستند اما تغییرناپذیرند. تفاوت‌ها:

• تغییرپذیری: لیست‌ها تغییر می‌کنند، تاپل‌ها نه.

تاپل = (1, 2, 3)

# تاپل[0] = 4 # خطا: تاپل تغییر نمی‌کند

• سرعت و حافظه: تاپل‌ها سریع‌تر و کم‌حافظه‌ترند.
• کاربرد: تاپل برای داده‌های ثابت (مثل مختصات)، لیست برای داده‌های پویا.

تبدیل لیست به تاپل و برعکس

تبدیل ساده است:

لیست = [1, 2, 3]

تاپل = tuple(لیست)

print(تاپل) # خروجی: (1, 2, 3)

جدید = list(تاپل)

print(جدید) # خروجی: [1, 2, 3]

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

ورودی کاربر رشته است. برای تبدیل به لیست:

ورودی = input(“اعداد را با فاصله وارد کنید: “).split()

اعداد = [int(x) for x in ورودی]

print(اعداد) # ورودی: “1 2 3” -> خروجی: [1, 2, 3]

کپی‌برداری: اجتناب از خطاها

لیست2 = لیست1 کپی نمی‌کند، مرجع می‌سازد. برای کپی:

لیست1 = [1, 2, 3]

لیست2 = لیست1.copy()

لیست2[0] = 0

print(لیست1, لیست2) # خروجی: [1, 2, 3] [0, 2, 3]

برای لیست‌های تو در تو، از copy.deepcopy استفاده کنید.

کاربردهای پیشرفته و نکات نهایی

لیست‌ها نه تنها ابزار، بلکه پلی به دنیای پیچیده‌تر پایتون هستند. با تسلط بر آن‌ها، از مدیریت ساده داده‌ها تا الگوریتم‌های پیشرفته، مسلط می‌شوید. تمرین کنید: یک برنامه فهرست وظایف بسازید با append، remove و sort. منابع مانند docs.python.org را کاوش کنید. اگر سوالی ماند، کد بزنید – پایتون منتظر شماست!