✅ آشنایی با MRO در پایتون (Method Resolution Order)

MRO یا Method Resolution Order در پایتون ترتیب جستجوی کلاس‌های پایه رو برای فراخوانی متدها مشخص می‌کنه. این موضوع مخصوصاً توی وراثت چندگانه خیلی مهمه چون مشخص می‌کنه که وقتی یک متد فراخوانی می‌شه، پایتون از کدوم کلاس استفاده کنه.

? چرا MRO مهمه؟
وقتی یک متد توی چند کلاس پایه (Parent Classes) وجود داشته باشه، پایتون از الگوریتم C3 Linearization استفاده می‌کنه تا ترتیب صحیح برای اجرای متدها رو پیدا کنه و از تداخل‌ها جلوگیری کنه.

? نحوه بررسی MRO
میتونی MRO یک کلاس رو با متد mro() یا ویژگی __mro__ ببینی:

```
class MyClass:
pass

print(MyClass.mro())
# یا
print(MyClass.__mro__)
```

? مثال ساده:

```
class A:
def method(self):
print("Method in A")

class B(A):
def method(self):
print("Method in B")

class C(B):
pass

c = C()
c.method() # خروجی: Method in B

print(C.mro())
```

? نتیجه MRO:

[<class '\_\_main\_\_.C'>, <class '\_\_main\_\_.B'>, <class '\_\_main\_\_.A'>, <class 'object'>]

?‍? وراثت چندگانه:
در وراثت چندگانه، پایتون MRO رو به این ترتیب محاسبه می‌کنه:

```
class A:
def method(self):
print("Method in A")

class B(A):
def method(self):
print("Method in B")

class C(A):
def method(self):
print("Method in C")

class D(B, C):
pass

d = D()
d.method() # خروجی: Method in B
```

? ترتیب MRO:

[<class '\_\_main\_\_.D'>, <class '\_\_main\_\_.B'>, <class '\_\_main\_\_.C'>, <class '\_\_main\_\_.A'>, <class 'object'>]

---

MRO یه مفهوم کلیدی برای مدیریت وراثت چندگانه در پایتونه که می‌تونه از تداخل‌ها جلوگیری کنه و کد رو تمیزتر کنه. برای یادگیری بیشتر، الگوریتم C3 Linearization رو بررسی کن!

@lython

Slots (Special Methods - Part 1)

✓ یک special attribute به نام slots هستش که با استفاده کردن از اون در کلاس هامون و بخصوص دیتا کلاس ها پرفورمنس استفاده از از کلاس رو چه در قسمت حافظه و چه در قسمت سرعت دسترسی به instance attribute ها افزایش بدهیم. به کد زیر دقت کنید، ابتدا سعی داریم یک دیتا کلاس ایجاد کنیم و نحوه ی استفاده از dict را نیز بیان کنیم.

```
class DataClass:
    def __init__(self, d1, d2):
        self.d1 = d1
        self.d2 = d2

object = DataClass(1, 2)
print(object.__dict__)

object.c3 = 3
print(object.__dict__)
```

خروجی کد بالا به شکل زیر است. در واقع می دانیم که می توان پس از مقداردهی و ایجاد شی مورد نظر به تمام Instacne Attribute های آن شی بوسیله ی dict دسترسی داشت.

{'d1': 1, 'd2': 2} {'d1': 1, 'd2': 2, 'd3': 3}

✓قابل ذکر است که چون دسترسی به ویژگی های درون شی و تغییرات و اضافه کردن آن ها مجاز است پس با اضافه کردن ویژگی به شی پس از ایجاد شی، به Special Attribute که ذکر کردیم نdictظور __dict__ است.)

✓ اما کاربرد Slot به چه شکل است؟

1- افزایش سرعت دسترسی به ویژگی ها
2-کاهش مصرف حافظه

✓ ۲ مزیت ذکر شده مرهون استفاده از همین یک خط کد در کلاس هاست و بخصوص کلاس هایی که قرار است ویژگی های زیادی داشته باشد و همچنین اشیای فراوانی از آن کلاس ساخته شود. همانطور که گفته شد این Special Attribute دسترسی به Attribute های درون یک کلاس را محدود خواهد کرد. و دیگر نمی توان مثل کد بالا d3 را به عنوان Instance Att به کلاس خود اضافه کنیم.

```
class DataClass:

Class(1, 2)= ('d1', 'd2')

def __init__(self, d1, d2):
         self.d1 = d1
         self.d2 = d2

object = DataClass(1, 2)
object.d3 = 5
```

اگر کد بالا اجرا شود به خطای زیر برمی خوریم. قابل ذکر است که دیگر اگر slots مثل کد بالا تعریف شود دیگر دسترسی به dict نیز امکان پذیر نیست.

AttributeError: 'DataClass' object has no attribute 'd3'

بعلاوه می توان slots را جوری تعریف کرد که در ادامه مجاز به تعریف Instance Attribute های خاصی پس از ایجاد شی باشیم. باز به کد زیر توجه شود.

```
class DataClass:

bject.c3 = = ('d1', 'd2', 'd3')

def __init__(self, d1, d2):
         self.d1 = d1
         self.d2 = d2

object = DataClass(1, 2)
object.d3 = 0
```

در این صورت امکان تعریف ویژگی d3 وجود دارد ولی ویژگی  دیگری را نمی توان تعریف کرد. این هم به خاطر این است که d3 در special attribute به نام slots تعریف شده است.

@lython

✅ا Decorators یکی از قابلیت‌های پیشرفته و بسیار قدرتمند پایتون هستند که برای تغییر یا افزایش قابلیت‌های توابع یا کلاس‌ها استفاده می‌شوند، بدون اینکه نیاز به تغییر کد اصلی آن‌ها باشد. بیایید به طور کامل با این مفهوم آشنا شویم.

◀️ا Decorators در واقع توابعی هستند که به عنوان ورودی یک تابع دیگر را می‌گیرند و یک تابع جدید برمی‌گردانند که معمولاً رفتار تابع ورودی را تغییر می‌دهد یا بهبود می‌بخشد.
چرا از Decorators استفاده می‌کنیم؟

ا Decorators به ما این امکان را می‌دهند که:

کد قابل استفاده مجدد بنویسیم: می‌توانیم منطق اضافی مانند ثبت لاگ، احراز هویت، بررسی نوع داده‌ها و ... را در یک مکان مرکزی قرار دهیم.
جداسازی منطق: می‌توانیم منطق Decorators را از منطق اصلی تابع جدا کنیم.
کاهش تکرار کد: با استفاده از Decorators می‌توانیم از نوشتن کد تکراری در مکان‌های مختلف جلوگیری کنیم.

مثال ساده از Decorators

فرض کنید می‌خواهیم یک Decorators بنویسیم که زمان اجرای یک تابع را اندازه‌گیری کند. ابتدا، یک تابع Decorators تعریف می‌کنیم:

```

import time

def time_decorator(func):
def wrapper(args, kwargs):
start_time = time.time()
result = func(args, **kwargs)
end_time = time.time()
print(f"Execution time of {func.__name__}: {end_time - start_time} seconds")
return result
return wrapper
```

حالا می‌توانیم از این Decorators برای یک تابع استفاده کنیم:

```

@time_decorator
def example_function():
time.sleep(2)
print("Function executed")

example_function()
```

توضیح کد

تعریف Decorators: time_decorator یک تابع است که تابع دیگری (func) را به عنوان ورودی می‌گیرد.
تعریف یک تابع داخلی (wrapper): این تابع داخلی تابع اصلی را احاطه می‌کند و وظیفه اندازه‌گیری زمان اجرای تابع اصلی را بر عهده دارد.
استفاده از @time_decorator: با استفاده از @time_decorator قبل از تعریف تابع example_function، تابع example_function با Decorators پیچیده می‌شود. حالا هر وقت example_function فراخوانی شود، در واقع wrapper اجرا می‌شود.

نتیجه

هنگامی که example_function را فراخوانی می‌کنیم، خروجی به صورت زیر خواهد بود:

```

Function executed
Execution time of example_function: 2.002345323562622 seconds
```

همانطور که می‌بینید، Decorators زمان اجرای تابع را محاسبه و چاپ می‌کند، در حالی که خود تابع اصلی بدون تغییر باقی می‌ماند.

Decorators در پایتون قابلیت‌های بسیار بیشتری دارند و می‌توانند به شکل‌های پیچیده‌تری استفاده شوند، اما این مثال ساده به شما یک دید کلی از نحوه عملکرد آن‌ها می‌دهد.
@lython

```
Data Class in python- part 1

✓ طبق تعریف کتاب وزین Fluent Python می‌توان تعریف جالبی برای دیتا کلاس‌ها ارائه داد.
Python offers a few ways to build a simple class that is just a collection of fields, with little or no extra functionality. p163
```

✓ درواقع دیتا کلاس‌ها ذاتا ظرفی هستن برای نگه‌داری داده‌ها، متدها در این نوع کلاس نقش بسیار کم‌رنگی ایفا می‌کنند یا حتی می‌توان گفت، هیچ نقشی ندارند. مگر این که کاربرد متدی به نگه‌داری یا تغییر داده‌ها مربوط باشد.
به هر حال می‌توان به سه نوع نوشتن دیتا کلاس‌ها اشاره کرد.

1\- @dataclasses.dataclass (python +3.7) 2\- collections.namedtuple (python +2.6) 3\- typing.NamedTuple (python +3.6)

✓ کتاب مثال جالبی زده است، فرض کنید که ما صرفا می‌خواهیم کلاسی تحت عنوان Coordinate تعریف کنیم که مختصات را در خود ذخیره کند.

class Coordinate:     def \_\_init\_\_(self, lat, lon):         self.lat = lat         self.lon = lon

✓ این کلاس به راحتی قابل تعریف بود، اما ایراداتی را دارد که در ادامه به بیان آن‌ها خواهیم پرداخت. به کد زیر دقت کنید.

moscow = Coordinate(55.76, 37.62) location = Coordinate(55.76, 37.62) ✓ دقت شود که مختصات جفت این ها یکسان است ولی وقتی  با == دو لوکیشن را مقایسه می‌کنیم به نتیجه دلخواه نخواهیم رسید زیرا مکان آن دو در حافظه درحال مقایسه است.

```

location == moscow
False
moscow

```

✓ پس دو مشکل اصلی را در حال نظاره‌ایم، یکی این که مجیک متد __repr__  را باید بازنویسی کنیم و به بازنویسی مجیک متد __eq__ نیز نیازمندیم. در ادامه از  اولین نوع دیتا کلاس استفاده خواهیم کرد. به کد زیر دقت کنید.

```
from dataclasess import dataclass

@dataclass(frozen=True)
class Coordinate:
    lat: float
    lon: float

moscow = Coordinate(lat= 55.76, lon= 37.62 )
location = Coordinate(lat= 55.76, lon= 37.62 )
```

✓ دقت شود که این نوع دیتا کلاس از تایپ هینت برای تعریف خود استفاده می‌کند و تایپ هینت یک نوع نوشتن آپشنال و اختیاری است و به هیچ عنوان قرار هم نیست که اجباری شود و فقط یک استثنا دارد آن هم دیتا کلاس است که باید در آن این Annotation رعایت گردد.

✓ مقدار frozen برابر True قرار داده شده، تا کلاس ایجاد شده immutable شود.

✓ نکته‌ی دیگری که باید در نظر گرفت، بهتر است که آرگومان‌های ورودی به صورت keyword only به دیتا کلاس برای ایجاد شیٔ داده شود زیرا ترتیب آرگومان‌های ورودی اینجا اهمیت دارد.
مشکلاتی که در تعریف قبلی کلاس Coordinate  به آن اشاره کردیم، در تعریف جدید به لطف باهوش بودن سازندگان پایتون حل شده است. کد زیر خود موضوع را روشن می‌کند.

```

moscow == location
True
moscow
Coordinate(lat= 55.76, lon= 37.62 )
```

یعنی دو مجیک متد ذکر شده برای دیتاکلاس ما از پیش تعریف شده است.
@lython

✅ تفاوت‌های کلیدی بین لیست‌ها و تاپل‌ها

قابلیت تغییر (Mutability)

لیست‌ها:

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

```

```

تاپل‌ها:

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

```

```

عملکرد (Performance)

لیست‌ها:

کندتر: به دلیل قابلیت تغییر، لیست‌ها دارای سربار (overhead) بیشتری هستند که می‌تواند منجر به کاهش کارایی در برخی موارد شود.

تاپل‌ها:

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

استفاده حافظه (Memory Usage)

لیست‌ها:

مصرف حافظه بیشتر: به دلیل قابلیت تغییر، لیست‌ها برای مدیریت تغییرات به فضای اضافی نیاز دارند.

تاپل‌ها:

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

امنیت داده (Data Integrity)

لیست‌ها:

کمتر امن: از آنجا که لیست‌ها قابل تغییر هستند، ممکن است به‌طور ناخواسته تغییر یابند و داده‌ها دچار ناپایداری شوند.

تاپل‌ها:

بیشتر امن: تاپل‌ها به دلیل غیرقابل تغییر بودن، امنیت داده‌ها را تضمین می‌کنند و برای استفاده در موقعیت‌هایی که نیاز به عدم تغییر داده‌ها داریم، مناسب‌تر هستند.

کاربرد (Usage)

لیست‌ها:

زمانی که نیاز به تغییرات مکرر دارید: برای مجموعه‌هایی از داده‌ها که به‌طور مداوم نیاز به اضافه کردن، حذف یا تغییر دارند، لیست‌ها مناسب‌تر هستند.

```

```

تاپل‌ها:

زمانی که نیاز به ثابت ماندن داده‌ها دارید: برای داده‌هایی که نباید تغییر کنند، مانند کلیدهای دیکشنری یا مقادیر ثابت در برنامه‌نویسی.

```

```

عملیات‌های مجاز

لیست‌ها:

پشتیبانی از تمام عملیات‌های تغییرپذیری مانند append(), remove(), insert(), pop(), و غیره.

تاپل‌ها:

پشتیبانی از عملیات دسترسی و شمارش عناصر مانند index() و count(), اما بدون قابلیت تغییر.

ترکیب داده‌ها (Concatenation) و تکرار (Repetition)
هر دو نوع داده از ترکیب و تکرار پشتیبانی می‌کنند، اما ترکیب و تکرار در تاپل‌ها منجر به ایجاد تاپل‌های جدید می‌شود.

```

# ترکیب
list1 = [1, 2]
list2 = [3, 4]
combined_list = list1 + list2
print(combined_list) # خروجی: [1, 2, 3, 4]

tuple1 = (1, 2)
tuple2 = (3, 4)
combined_tuple = tuple1 + tuple2
print(combined_tuple) # خروجی: (1, 2, 3, 4)

# تکرار
repeated_list = list1 * 3
print(repeated_list) # خروجی: [1, 2, 1, 2, 1, 2]

repeated_tuple = tuple1 * 3
print(repeated_tuple) # خروجی: (1, 2, 1, 2, 1, 2)
```

تبدیل بین لیست و تاپل

گاهی اوقات نیاز به تبدیل بین این دو نوع داده وجود دارد.

```

# لیست به تاپل
my_list = [1, 2, 3]
my_tuple = tuple(my_list)
print(my_tuple) # خروجی: (1, 2, 3)

# تاپل به لیست
my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(my_list) # خروجی: [1, 2, 3]
```

نتیجه‌گیری

لیست‌ها برای مواردی مناسب هستند که نیاز به تغییر، اضافه کردن یا حذف عناصر دارید. از لیست‌ها در برنامه‌هایی استفاده کنید که انعطاف‌پذیری داده‌ها مهم است.
تاپل‌ها برای مواردی مناسب هستند که داده‌ها باید ثابت بمانند و بهینه‌سازی عملکرد و استفاده از حافظه مهم است. از تاپل‌ها در مواردی استفاده کنید که داده‌ها نباید تغییر کنند و امنیت داده‌ها حائز اهمیت است

@lython

✅ تاپل‌ها در پایتون: مفاهیم پیشرفته

1️⃣ تعریف تاپل

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

```

my_tuple = (1, 2, 3, 'hello', 4.5)
print(my_tuple) # خروجی: (1, 2, 3, 'hello', 4.5)
```

2️⃣ دسترسی به عناصر تاپل

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

```

print(my_tuple[0]) # خروجی: 1
print(my_tuple[3]) # خروجی: hello
print(my_tuple[-1]) # خروجی: 4.5
```

3️⃣ برش (Slicing)

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

```

print(my_tuple[1:4]) # خروجی: (2, 3, 'hello')
print(my_tuple[:3]) # خروجی: (1, 2, 3)
print(my_tuple[2:]) # خروجی: (3, 'hello', 4.5)
print(my_tuple[::-1]) # خروجی: (4.5, 'hello', 3, 2, 1)
```

4️⃣ تاپل‌های تودرتو (Nested Tuples)

تاپل‌ها می‌توانند شامل تاپل‌ها و یا هر نوع داده دیگری باشند که به آن‌ها تاپل‌های تودرتو گفته می‌شود.

```

nested_tuple = (1, 2, (3, 4), (5, (6, 7)))
print(nested_tuple[2]) # خروجی: (3, 4)
print(nested_tuple[3][1]) # خروجی: (6, 7)
print(nested_tuple[3][1][1]) # خروجی: 7
```

5️⃣ توابع کاربردی برای تاپل‌ها

پایتون توابع مختلفی را برای کار با تاپل‌ها ارائه می‌دهد:

len(): طول تاپل را برمی‌گرداند.
sum(): مجموع عناصر عددی تاپل را محاسبه می‌کند.
min() و max(): کوچک‌ترین و بزرگ‌ترین عنصر عددی تاپل را برمی‌گرداند.
sorted(): یک لیست مرتب‌شده از عناصر تاپل برمی‌گرداند.

```

num_tuple = (3, 1, 4, 1, 5, 9, 2, 6)

print(len(num_tuple)) # خروجی: 8
print(sum(num_tuple)) # خروجی: 31
print(min(num_tuple)) # خروجی: 1
print(max(num_tuple)) # خروجی: 9
print(sorted(num_tuple)) # خروجی: [1, 1, 2, 3, 4, 5, 6, 9]
```

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

می‌توانید با استفاده از توابع tuple() و list() بین لیست‌ها و تاپل‌ها تبدیل انجام دهید.

```

my_list = [1, 2, 3]
my_tuple = tuple(my_list)
print(my_tuple) # خروجی: (1, 2, 3)

new_list = list(my_tuple)
print(new_list) # خروجی: [1, 2, 3]
```

7️⃣ عملیات‌های متداول

عملیات‌هایی مانند الحاق (concatenation) و تکرار (repetition) بر روی تاپل‌ها امکان‌پذیر است.

```

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)

# الحاق
combined_tuple = tuple1 + tuple2
print(combined_tuple) # خروجی: (1, 2, 3, 4, 5, 6)

# تکرار
repeated_tuple = tuple1 * 3
print(repeated_tuple) # خروجی: (1, 2, 3, 1, 2, 3, 1, 2, 3)
```

8️⃣ تاپل‌های چند بعدی

می‌توانید تاپل‌های چند بعدی بسازید و با آن‌ها کار کنید.

```

matrix = ((1, 2, 3),
(4, 5, 6),
(7, 8, 9))

# دسترسی به عناصر ماتریس
print(matrix[1][2]) # خروجی: 6

# پیمایش در ماتریس
for row in matrix:
for item in row:
print(item, end=' ') # خروجی: 1 2 3 4 5 6 7 8 9 (4, 5, 6),
(7, 8, 9))

# دسترسی به عناصر ماتریس
print(matrix[1][2]) # خروجی: 6

# پیمایش در ماتریس
for row in matrix:
for item in row:
print(item, end=' ') # خروجی: 1 2 3 4 5 6 7 8 9
```

@lython

✅ لیست‌ها در پایتون: مفاهیم پیشرفته

1️⃣ برش (Slicing)

برش به شما اجازه می‌دهد تا زیرمجموعه‌ای از لیست را بدست آورید. سینتکس برش به صورت [start:stop:step] است.

```

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# برش ساده
print(my_list[2:5]) # خروجی: [2, 3, 4]

# برش با گام
print(my_list[1:8:2]) # خروجی: [1, 3, 5, 7]

# برش از ابتدا تا یک نقطه
print(my_list[:4]) # خروجی: [0, 1, 2, 3]

# برش از یک نقطه تا انتها
print(my_list[5:]) # خروجی: [5, 6, 7, 8, 9]

# برش با گام منفی (برعکس)
print(my_list[::-1]) # خروجی: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
```

2️⃣ لیست‌های تودرتو (Nested Lists)

لیست‌ها می‌توانند شامل لیست‌های دیگر باشند که به آن‌ها لیست‌های تودرتو گفته می‌شود.

```

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# دسترسی به عنصر خاص در لیست تودرتو
print(nested_list[0][1]) # خروجی: 2

# پیمایش در لیست‌های تودرتو
for sublist in nested_list:
for item in sublist:
print(item, end=' ') # خروجی: 1 2 3 4 5 6 7 8 9
```

3️⃣ لیست‌های درک شده (List Comprehensions)

لیست‌های درک شده یک راه کوتاه برای ایجاد لیست‌ها هستند.

```

# ایجاد لیستی از اعداد مربعی
squares = [x**2 for x in range(10)]
print(squares) # خروجی: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# فیلتر کردن لیست
evens = [x for x in range(10) if x % 2 == 0]
print(evens) # خروجی: [0, 2, 4, 6, 8]
```

4️⃣ توابع کاربردی برای لیست‌ها

پایتون توابع مختلفی را برای کار با لیست‌ها ارائه می‌دهد:

```
len(): طول لیست را برمی‌گرداند.
sum(): مجموع عناصر لیست را محاسبه می‌کند.
min() و max(): کوچک‌ترین و بزرگ‌ترین عنصر لیست را برمی‌گرداند.
sorted(): لیست را مرتب می‌کند.
reversed(): لیست را معکوس می‌کند.

```

```
my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5]

print(len(my_list)) # خروجی: 9
print(sum(my_list)) # خروجی: 36
print(min(my_list)) # خروجی: 1
print(max(my_list)) # خروجی: 9
print(sorted(my_list)) # خروجی: [1, 1, 2, 3, 4, 5, 5, 6, 9]
print(list(reversed(my_list))) # خروجی: [5, 6, 2, 9, 5, 1, 4, 1, 3]
```

5️⃣ توابع و متدهای پیشرفته

index(): اندیس اولین وقوع عنصر مورد نظر را برمی‌گرداند. count(): تعداد وقوع یک عنصر را در لیست برمی‌گرداند. insert(): یک عنصر را در اندیس مشخصی اضافه می‌کند. pop(): عنصر با اندیس مشخصی را حذف و برمی‌گرداند. remove(): اولین وقوع عنصر مورد نظر را حذف می‌کند. clear(): تمام عناصر لیست را حذف می‌کند.

```

my_list = [1, 2, 3, 2, 4, 2]

print(my_list.index(2)) # خروجی: 1
print(my_list.count(2)) # خروجی: 3

my_list.insert(3, 'a')
print(my_list) # خروجی: [1, 2, 3, 'a', 2, 4, 2]

print(my_list.pop(3)) # خروجی: 'a'
print(my_list) # خروجی: [1, 2, 3, 2, 4, 2]

my_list.remove(2)
print(my_list) # خروجی: [1, 3, 2, 4, 2]

my_list.clear()
print(my_list) # خروجی: []
```

6️⃣ لیست‌های چند بعدی

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

```

matrix = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]

# دسترسی به عناصر ماتریس
print(matrix[1][2]) # خروجی: 6

# پیمایش در ماتریس
for row in matrix:
for item in row:
print(item, end=' ') # خروجی: 1 2 3 4 5 6 7 8 9
```

@lython