“`html

ساختمان داده در پایتون: چیت شیت برای استفاده بهینه

پایتون، به عنوان یکی از محبوب‌ترین زبان‌های برنامه‌نویسی، به دلیل سادگی، خوانایی و کتابخانه‌های گسترده، انتخابی ایده‌آل برای توسعه‌دهندگان در سطوح مختلف است. یکی از جنبه‌های کلیدی برنامه‌نویسی کارآمد، درک و استفاده صحیح از ساختمان داده‌ها است. انتخاب ساختمان داده مناسب می‌تواند تاثیر بسزایی در عملکرد، حافظه مصرفی و خوانایی کد داشته باشد. این چیت شیت جامع، به شما کمک می‌کند تا ساختمان داده‌های اصلی پایتون را به طور کامل درک کرده و از آن‌ها بهینه استفاده کنید.

1. لیست‌ها (Lists): آرایه‌های پویا و همه‌کاره

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

1.1. ویژگی‌های کلیدی لیست‌ها:

• مرتب بودن: عناصر لیست‌ها بر اساس ترتیب اضافه شدن، دارای اندیس هستند.
• قابل تغییر بودن: امکان اضافه، حذف و تغییر عناصر لیست وجود دارد.
• پویا بودن: اندازه لیست‌ها به طور خودکار با اضافه و حذف عناصر تغییر می‌کند.
• امکان ذخیره انواع داده‌های مختلف: یک لیست می‌تواند شامل عناصری از انواع مختلف داده باشد.
• دسترسی از طریق اندیس: عناصر لیست از طریق اندیس (index) قابل دسترسی هستند (اندیس از 0 شروع می‌شود).

1.2. عملیات رایج روی لیست‌ها:

• ایجاد لیست:

  my_list = [1, 2, "hello", 3.14]

• دسترسی به عناصر:

  first_element = my_list[0]  # 1
  last_element = my_list[-1] # 3.14

• برش لیست (Slicing):

  sub_list = my_list[1:3]  # [2, "hello"]
  every_other = my_list[::2] # [1, "hello"]

• اضافه کردن عنصر:

  my_list.append("world")  # adds "world" to the end
  my_list.insert(2, "new")   # inserts "new" at index 2

• حذف عنصر:

  my_list.remove("hello")  # removes the first occurrence of "hello"
  popped_element = my_list.pop(1) # removes and returns the element at index 1

• جستجو در لیست:

  index = my_list.index("world") # returns the index of "world"
  count = my_list.count(1)     # returns the number of times 1 appears

• مرتب‌سازی لیست:

  my_list.sort()          # sorts the list in place (ascending order)
  my_list.sort(reverse=True) # sorts the list in place (descending order)
  sorted_list = sorted(my_list) # returns a new sorted list

1.3. ملاحظات عملکردی:

در حالی که لیست‌ها بسیار انعطاف‌پذیر هستند، عملیات خاصی ممکن است از نظر عملکردی پرهزینه باشند:

• درج و حذف در ابتدا یا میانه لیست: این عملیات‌ها نیاز به جابجایی عناصر دارند و زمان اجرای آن‌ها O(n) است (n تعداد عناصر لیست).
• جستجو در لیست‌های بزرگ: عملگر in و متد index در لیست‌ها، به صورت خطی جستجو می‌کنند (O(n)).

1.4. بهترین زمان استفاده از لیست‌ها:

• وقتی نیاز به مجموعه‌ای مرتب از عناصر دارید.
• وقتی تعداد عناصر در طول اجرای برنامه تغییر می‌کند.
• وقتی نیاز به ذخیره انواع داده‌های مختلف در یک مجموعه دارید.
• وقتی ترتیب عناصر مهم است و نیاز به دسترسی از طریق اندیس دارید.

2. تاپل‌ها (Tuples): لیست‌های تغییرناپذیر

تاپل‌ها مشابه لیست‌ها هستند، با این تفاوت که **تغییرناپذیر (immutable)** هستند. این بدان معناست که پس از ایجاد یک تاپل، نمی‌توان عناصر آن را تغییر داد، اضافه کرد یا حذف کرد. تاپل‌ها معمولاً برای ذخیره مجموعه‌هایی از داده‌ها استفاده می‌شوند که نباید تغییر کنند، مانند مختصات یک نقطه، یا اطلاعات مربوط به یک رکورد در پایگاه داده.

2.1. ویژگی‌های کلیدی تاپل‌ها:

• مرتب بودن: عناصر تاپل‌ها بر اساس ترتیب اضافه شدن، دارای اندیس هستند.
• تغییرناپذیر بودن: عناصر تاپل را نمی‌توان پس از ایجاد، تغییر داد.
• پویا بودن (غیرمستقیم): اگرچه خود تاپل تغییرناپذیر است، اما اگر شامل اشیاء تغییرپذیر (مانند لیست‌ها) باشد، محتوای آن اشیاء می‌تواند تغییر کند.
• امکان ذخیره انواع داده‌های مختلف: یک تاپل می‌تواند شامل عناصری از انواع مختلف داده باشد.
• دسترسی از طریق اندیس: عناصر تاپل از طریق اندیس (index) قابل دسترسی هستند (اندیس از 0 شروع می‌شود).
• استفاده به عنوان کلید در دیکشنری‌ها: تاپل‌ها به دلیل تغییرناپذیر بودن، می‌توانند به عنوان کلید در دیکشنری‌ها استفاده شوند (لیست‌ها نمی‌توانند).

2.2. عملیات رایج روی تاپل‌ها:

• ایجاد تاپل:

  my_tuple = (1, 2, "hello", 3.14)
  empty_tuple = ()
  single_element_tuple = (5,)  # Note the trailing comma

• دسترسی به عناصر:

  first_element = my_tuple[0]  # 1
  last_element = my_tuple[-1] # 3.14

• برش تاپل (Slicing):

  sub_tuple = my_tuple[1:3]  # (2, "hello")

• شمارش عناصر:

  count = my_tuple.count(1)     # returns the number of times 1 appears

• یافتن اندیس:

  index = my_tuple.index("hello") # returns the index of "hello"

2.3. ملاحظات عملکردی:

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

2.4. بهترین زمان استفاده از تاپل‌ها:

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

3. دیکشنری‌ها (Dictionaries): ساختارهای کلید-مقدار

دیکشنری‌ها در پایتون، ساختارهای داده‌ای هستند که مجموعه‌ای از جفت‌های کلید-مقدار (key-value pairs) را ذخیره می‌کنند. کلیدها باید منحصربه‌فرد و تغییرناپذیر باشند (مانند رشته‌ها، اعداد و تاپل‌ها)، در حالی که مقادیر می‌توانند از هر نوع داده‌ای باشند. دیکشنری‌ها برای ذخیره و بازیابی اطلاعات بر اساس کلیدها بسیار کارآمد هستند.

3.1. ویژگی‌های کلیدی دیکشنری‌ها:

• کلید-مقدار: داده‌ها به صورت جفت‌های کلید-مقدار ذخیره می‌شوند.
• کلیدهای منحصربه‌فرد: هر کلید در یک دیکشنری باید منحصربه‌فرد باشد.
• تغییرپذیر بودن: امکان اضافه، حذف و تغییر مقادیر دیکشنری وجود دارد.
• دسترسی سریع: دسترسی به مقادیر بر اساس کلید، بسیار سریع است (به طور متوسط O(1)).
• بدون ترتیب: ترتیب عناصر در دیکشنری حفظ نمی‌شود (از پایتون 3.7 به بعد، ترتیب درج کلیدها حفظ می‌شود).

3.2. عملیات رایج روی دیکشنری‌ها:

• ایجاد دیکشنری:

  my_dict = {"name": "Alice", "age": 30, "city": "New York"}
  empty_dict = {}

• دسترسی به مقادیر:

  name = my_dict["name"] # "Alice"
  age = my_dict.get("age") # 30 (returns None if key doesn't exist)

• اضافه کردن عنصر:

  my_dict["occupation"] = "Engineer"

• تغییر مقدار:

  my_dict["age"] = 31

• حذف عنصر:

  del my_dict["city"]
  popped_value = my_dict.pop("age") # removes and returns the value associated with "age"

• بررسی وجود کلید:

  if "name" in my_dict:
    print("Name exists")

• دریافت کلیدها، مقادیر و آیتم‌ها:

  keys = my_dict.keys()   # returns a view object of the keys
  values = my_dict.values() # returns a view object of the values
  items = my_dict.items()   # returns a view object of (key, value) pairs

3.3. ملاحظات عملکردی:

• دسترسی: دسترسی به عناصر در دیکشنری‌ها به طور متوسط O(1) است (با استفاده از جداول هش).
• حافظه: دیکشنری‌ها معمولاً حافظه بیشتری نسبت به لیست‌ها و تاپل‌ها مصرف می‌کنند، زیرا نیاز به ذخیره کلیدها و مقادیر دارند.

3.4. بهترین زمان استفاده از دیکشنری‌ها:

• وقتی نیاز به ذخیره و بازیابی اطلاعات بر اساس کلیدها دارید.
• وقتی می‌خواهید دسترسی سریع به اطلاعات داشته باشید.
• وقتی نیاز به نمایش ارتباط بین دو مجموعه از داده‌ها دارید (کلیدها و مقادیر).

4. مجموعه‌ها (Sets): مجموعه‌های بدون ترتیب و منحصربه‌فرد

مجموعه‌ها در پایتون، مجموعه‌های بدون ترتیب از عناصر منحصربه‌فرد هستند. آن‌ها برای انجام عملیات مجموعه‌ای مانند اجتماع، اشتراک، تفاضل و بررسی عضویت بسیار کارآمد هستند. مجموعه‌ها نمی‌توانند شامل عناصر تکراری باشند و ترتیب عناصر در آن‌ها مهم نیست.

4.1. ویژگی‌های کلیدی مجموعه‌ها:

• منحصربه‌فرد بودن: هر عنصر در یک مجموعه باید منحصربه‌فرد باشد.
• بدون ترتیب: ترتیب عناصر در مجموعه حفظ نمی‌شود.
• تغییرپذیر بودن: امکان اضافه و حذف عناصر از مجموعه وجود دارد.
• عملکرد سریع برای عملیات مجموعه‌ای: عملیاتی مانند اجتماع، اشتراک و تفاضل به سرعت انجام می‌شوند.
• عناصر تغییرناپذیر: عناصر مجموعه باید تغییرناپذیر باشند (مانند اعداد، رشته‌ها و تاپل‌ها).

4.2. عملیات رایج روی مجموعه‌ها:

• ایجاد مجموعه:

  my_set = {1, 2, 3, 4, 5}
  empty_set = set() # Note: {} creates an empty dictionary, not an empty set!

• اضافه کردن عنصر:

  my_set.add(6)

• حذف عنصر:

  my_set.remove(3)  # raises KeyError if element doesn't exist
  my_set.discard(4) # removes element if it exists, otherwise does nothing

• بررسی عضویت:

  if 2 in my_set:
    print("2 is in the set")

• عملیات مجموعه‌ای:

  other_set = {4, 5, 6, 7}
  union_set = my_set.union(other_set)        # {1, 2, 5, 6, 7}
  intersection_set = my_set.intersection(other_set) # {4, 5}
  difference_set = my_set.difference(other_set)     # {1, 2}
  symmetric_difference_set = my_set.symmetric_difference(other_set) # {1, 2, 6, 7}

4.3. ملاحظات عملکردی:

• بررسی عضویت: بررسی عضویت در مجموعه‌ها به طور متوسط O(1) است (با استفاده از جداول هش).
• عملیات مجموعه‌ای: عملیات مجموعه‌ای به طور کلی بسیار کارآمد هستند.

4.4. بهترین زمان استفاده از مجموعه‌ها:

• وقتی نیاز به مجموعه‌ای از عناصر منحصربه‌فرد دارید.
• وقتی نیاز به انجام عملیات مجموعه‌ای دارید.
• وقتی نیاز به بررسی سریع عضویت دارید.

5. آرایه‌ها (Arrays): آرایه‌هایی با نوع داده یکسان (با استفاده از ماژول array)

در پایتون، لیست‌ها می‌توانند انواع داده‌های مختلف را در خود جای دهند. اما گاهی اوقات نیاز به ذخیره مجموعه‌ای از عناصر با نوع داده یکسان (مانند اعداد صحیح یا اعداد اعشاری) دارید. در این موارد، استفاده از ماژول `array` می‌تواند کارآمدتر باشد. آرایه‌ها در ماژول `array` فضای حافظه کمتری نسبت به لیست‌ها مصرف می‌کنند و عملیات روی آن‌ها سریع‌تر انجام می‌شود.

5.1. ویژگی‌های کلیدی آرایه‌ها (با استفاده از ماژول array):

• نوع داده یکسان: تمام عناصر آرایه باید از یک نوع داده باشند.
• فضای حافظه کارآمد: آرایه‌ها فضای حافظه کمتری نسبت به لیست‌ها مصرف می‌کنند.
• دسترسی سریع: دسترسی به عناصر آرایه سریع‌تر از لیست‌ها است.
• تغییرپذیر بودن: عناصر آرایه را می‌توان تغییر داد.
• اندازه ثابت: اندازه آرایه می‌تواند ثابت یا پویا باشد (بسته به نحوه استفاده).

5.2. عملیات رایج روی آرایه‌ها (با استفاده از ماژول array):

import array

# Creating an array of integers
my_array = array.array('i', [1, 2, 3, 4, 5]) # 'i' specifies integer type

# Accessing elements
first_element = my_array[0]  # 1

# Appending an element
my_array.append(6)

# Inserting an element
my_array.insert(2, 10)

# Removing an element
my_array.remove(3)

# Converting to list
my_list = my_array.tolist()

5.3. کد تایپ‌ها (Type Codes) در ماژول array:

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

• 'b': عدد صحیح علامت‌دار (signed char)
• 'B': عدد صحیح بدون علامت (unsigned char)
• 'h': عدد صحیح علامت‌دار کوتاه (signed short)
• 'H': عدد صحیح بدون علامت کوتاه (unsigned short)
• 'i': عدد صحیح علامت‌دار (signed int)
• 'I': عدد صحیح بدون علامت (unsigned int)
• 'l': عدد صحیح علامت‌دار بلند (signed long)
• 'L': عدد صحیح بدون علامت بلند (unsigned long)
• 'f': عدد اعشاری تک‌دقت (float)
• 'd': عدد اعشاری دودقت (double)

5.4. ملاحظات عملکردی:

• حافظه: آرایه‌ها حافظه کمتری نسبت به لیست‌ها مصرف می‌کنند، به‌ویژه برای آرایه‌های بزرگ.
• سرعت: عملیات روی آرایه‌ها معمولاً سریع‌تر از لیست‌ها است.
• محدودیت نوع داده: تمام عناصر آرایه باید از یک نوع داده باشند.

5.5. بهترین زمان استفاده از آرایه‌ها (با استفاده از ماژول array):

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

6. صف‌ها (Queues): ساختارهای FIFO

صف‌ها ساختارهای داده‌ای هستند که از اصل “اولین ورودی، اولین خروجی” (FIFO – First-In, First-Out) پیروی می‌کنند. عناصری که زودتر به صف اضافه می‌شوند، زودتر از صف خارج می‌شوند. صف‌ها در بسیاری از برنامه‌ها کاربرد دارند، مانند مدیریت درخواست‌ها در یک سرور، پردازش وظایف در یک سیستم عامل و شبیه‌سازی سیستم‌های دنیای واقعی.

6.1. پیاده‌سازی صف‌ها در پایتون:

در پایتون، می‌توان صف‌ها را با استفاده از ماژول `queue` یا ماژول `collections.deque` پیاده‌سازی کرد. `collections.deque` معمولاً برای صف‌های با کارایی بالا ترجیح داده می‌شود.

6.2. استفاده از `collections.deque`:

from collections import deque

# Creating a queue
my_queue = deque()

# Adding elements to the queue (enqueue)
my_queue.append(1)
my_queue.append(2)
my_queue.append(3)

# Removing elements from the queue (dequeue)
first_element = my_queue.popleft() # 1

# Checking if the queue is empty
if len(my_queue) == 0:
  print("Queue is empty")

6.3. ویژگی‌های کلیدی صف‌ها:

• FIFO: اولین عنصر اضافه شده، اولین عنصری است که حذف می‌شود.
• enqueue: اضافه کردن عنصر به انتهای صف.
• dequeue: حذف عنصر از ابتدای صف.

6.4. بهترین زمان استفاده از صف‌ها:

• وقتی نیاز به پردازش عناصر بر اساس ترتیب ورود دارید.
• وقتی نیاز به مدیریت درخواست‌ها در یک سرور دارید.
• وقتی نیاز به شبیه‌سازی سیستم‌های دنیای واقعی دارید.

7. پشته‌ها (Stacks): ساختارهای LIFO

پشته‌ها ساختارهای داده‌ای هستند که از اصل “آخرین ورودی، اولین خروجی” (LIFO – Last-In, First-Out) پیروی می‌کنند. عنصری که آخر از همه به پشته اضافه می‌شود، اولین عنصری است که از پشته خارج می‌شود. پشته‌ها در بسیاری از برنامه‌ها کاربرد دارند، مانند مدیریت فراخوانی توابع در یک برنامه، ارزیابی عبارات ریاضی و پیاده‌سازی الگوریتم‌های جستجو.

7.1. پیاده‌سازی پشته‌ها در پایتون:

در پایتون، می‌توان پشته‌ها را به سادگی با استفاده از لیست‌ها پیاده‌سازی کرد. متد `append` برای اضافه کردن عنصر به بالای پشته و متد `pop` برای حذف عنصر از بالای پشته استفاده می‌شود.

7.2. استفاده از لیست‌ها برای پیاده‌سازی پشته:

# Creating a stack
my_stack = []

# Adding elements to the stack (push)
my_stack.append(1)
my_stack.append(2)
my_stack.append(3)

# Removing elements from the stack (pop)
last_element = my_stack.pop() # 3

# Checking if the stack is empty
if len(my_stack) == 0:
  print("Stack is empty")

7.3. ویژگی‌های کلیدی پشته‌ها:

• LIFO: آخرین عنصر اضافه شده، اولین عنصری است که حذف می‌شود.
• push: اضافه کردن عنصر به بالای پشته.
• pop: حذف عنصر از بالای پشته.

7.4. بهترین زمان استفاده از پشته‌ها:

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

8. انتخاب ساختمان داده مناسب: یک جمع‌بندی

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

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

“`