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

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

int my_cool_array[3] = {1, 2, 3};

در پایتون چیزی به اسم آرایه نداریم. خود زبان به صورت ذاتی(منظورم builtin یا توکار هست) چند نوع مخزن دارد که این‌جا من در مورد دو مورد از آن‌ها برایتان می‌نویسم.

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

لیست‌ها(Lists)

در پایتون لیست‌ها را زیاد استفاده خواهید کرد. اعضای یک لیست می‌توانند هر کدام تقریبا هرچیزی باشند. مثلا انواع اعداد(مختلط،صحیح،اعشاری،کسری و …) یا یک مخزن دیگر(لیست یا توپل یا …) یا نمونه کلاس‌ها. حتی می‌توانید خود کلاس‌ها و یا توابع را نیز در یک لیست توکار پایتون ذخیره‌کنید. تک‌تک اعضای یک لیست با اندیس‌گذاری مشخص می‌شوند و اعضا ترتیب دارند. علاوه بر‌آن لیست‌ها قابل ویرایش(mutable) هستند به این معنی که می‌توانید بدون ساختن لیست جدید، اعضا را به یک لیست اضافه یا کم کنید یا مثلا ترتیب اعضا را تغییر دهید(مثلا کل لیست را درجا برعکس یا مرتب کنید). همچنین کمابیش می‌توانید یک لیست را به همراه متد های append و pop به عنوان یک پشته یا استک(stack) استفاده کنید.

>>> my_list = [0, 2, 10]
>>> print(my_list[1])
2
>>> print(my_list[-1])
10
>>> another_list = [my_list, None, [[[[my_list]]]]]
>>> print(another_list)
[[0, 2, 10], None, [[[[[0, 2, 10]]]]]]

متد‌هایی که یک نمونه لیست پشتیبانی می‌کند

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

متد append تنها یک آرگامون می‌گیرد و ورودی را به لیست اضافه می‌کند:

>>> my_list = [1, 2, complex(1,2)]
>>> my_list.append(0)
>>> print(my_list)
[1, 2, (1+2j), 0]

خالی کردن لیست

متد clear تمام عناصر لیست را حذف می‌کند.

>>> my_list = [1,2,3,4]
>>> print(my_list)
[1, 2, 3, 4]
>>> my_list.clear()
>>> print(my_list)
[]

کپی سطحی از لیست

copy یک کپی سطحی از لیست درست می‌کند.

تعداد تکرار‌های یک عضو مشخص در لیست

متد count تنها یک ورودی می‌گیرد و تعداد تکرار‌های آن مقدار در لیست را به صورت یک عدد صحیح بر میگرداند.

>>> my = [1,2,3,4,5,1,1,521,412,1,1,1,12]
>>> print(my.count(...))
0
>>> print(my.count(1))
6
>>> print(my.count(4))
1

توسعه لیست بوسیله یک مخزن دیگر

متد extend یک مخزن دیگر(یک شی قابل iterate کردن)، مثلا یک لیست یا توپل، را دریافت کرده و تمام اعضای آن را به لیست اضافه می‌کند.

>>> my = [1,2,3]
>>> my.extend(my)
>>> print(my)
[1, 2, 3, 1, 2, 3]
>>> my.extend({None, ..., 1})
>>> print(my)
[1, 2, 3, 1, 2, 3, None, Ellipsis, 1]

پیدا کردن اندیس یک مقدار در لیست

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

>>> my = list(range(0, 16, 2))
>>> print(my)
[0, 2, 4, 6, 8, 10, 12, 14]
>>> my.index(0)
0
>>> my.index(4)
2
>>> my.index(11)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 11 is not in list

همچنین می‌توانید آرگامون‌های start ویا stop(به ترتیب) را به این متد بدهید تا تنها در عناصری با اندیسی بین start و stop بگردد(یا start تا آخر لیست در صورتی که stop داده نشود).

>>> my = list(range(0, 16, 2))
>>> my.extend(my)
>>> print(my)
[0, 2, 4, 6, 8, 10, 12, 14, 0, 2, 4, 6, 8, 10, 12, 14]
>>> my.index(0)
0
>>> my.index(0, 3)
8

اضافه کردن یک مقدار در موقعیتی خاص

با استفاده از متد insert می‌توانید در موقعیت دلخواه در لیست یک عنصر را اضافه کنید.

>>> my = [1,2,3]
>>> my.insert(1,10)
>>> my
[1, 10, 2, 3]

همینطور که در مثال بالا میبینید عدد ۱۰ در مکانی قبل از مکان عنصر ۱ ام قرار گرفته و خودش شده عنصر ۱ ام.

حذف کردن و برگرداندن یک عنصر از لیست بر اساس اندیس

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

>>> my = [1,2,3,4]
>>> my.pop()
4
>>> my
[1, 2, 3]
>>> my.pop(0)
1
>>> my
[2, 3]

حذف کردن اولین تکرار یک عنصر از لیست بر اساس مقدار

متد remove لیست را برای مقدار داده شده پیمایش می‌کند و به محض یافتن آن، از لیست حذفش می‌کند و در صورتی که پیدا نکرد، استثنا ValueError پرت می‌کند.

>>> my = [1,2,3,4,1]
>>> my.remove(1)
>>> my
[2, 3, 4, 1]
>>> my.remove(2)
>>> my
[3, 4, 1]

مرتب کردن و برعکس کردن لیست

متد‌های sort و reverse به ترتیب یک لیست را مرتب و برعکس می‌کنند. این دو متد لیست را ویرایش می‌کنند و لیست جدیدی نمی‌سازند.

>>> my = [1,2,4,1,1,2,3,5]
>>> my.sort()
>>> my
[1, 1, 1, 2, 2, 3, 4, 5]
>>> my.reverse()
>>> my
[5, 4, 3, 2, 2, 1, 1, 1]

توجه کنید که در مورد متد sort اعضای لیست باید با هم قابل مقایسه باشند. به متد sort می‌توانید آرگامون های key و reverse را نیز بدهید. اولی باید یک تابع باشد که به تک تک عناصر اعمال می‌شود و مقدار بازگشتی به جای خود عناصر برای مرتب‌سازی استفاده می‌گردد. دومی نیز باید یک مقدار بولی باشد(به صورت پیش‌فرض False) که مشخص می‌کند لیست صعودی مرتب شود یا نزولی. این متد از الگوریتم تیم‌سورت استفاده می‌کند که مخصوص زبان پایتون توسط تیم پیترز در سال ۲۰۰۲ میلادی پیاده‌سازی شده.

یک کاربرد آرگامون key زمانیست که چند نمونه از یک کلاس سفارشی دارید و می‌خواهید نمونه‌ها را بر اساس مقادیر یک مشخصه خاص آن‌ها مرتب کنید:

>>> class Human:
...  def __init__(self, age):
...   self.age = age
...  def __str__(self):
...   return f"<Human age:{self.age}>"
... 
>>> farooqkz = Human(age=20)
>>> bsimjoo = Human(age=21)
>>> yoda = Human(age=900)
>>> pcworms_and_yoda = [farooqkz, bsimjoo, yoda]
>>> pcworms_and_yoda
[<__main__.Human object at 0x7f907d00cee0>, <__main__.Human object at 0x7f907d067700>, <__main__.Human object at 0x7f907cf971f0>]
>>> print(*pcworms_and_yoda)
<Human age:20> <Human age:21> <Human age:900>
>>> pcworms_and_yoda.sort(key=lambda h: h.age, reverse=True)
>>> print(*pcworms_and_yoda)
<Human age:900> <Human age:21> <Human age:20>

توپل‌ها(tuple یا تاپل)

توپل‌ها شباهات زیادی به لیست‌ها دارند اما در عوض مصرف کمتر حافظه و سرعت بیشتر، قابل ویرایش کردن نیستند(immutable). توپل از میان متد‌هایی که توسط تنها index و count را پشتیبانی می‌کند که درست مانند نسخه لیستی رفتار می‌کنند. با توجه به اینکه توپل‌ها را نمی‌توانید ویرایش کنید برای مرتب کردن یا برعکس کردن آن‌ها بایست از چیز‌هایی مثل sorted یا reversed استفاده کنید.

عملگر‌هایی(operators) که می‌توانید با لیست‌ها و توپل‌ها استفاده کنید

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

سینتکس عملگر	توضیحات
i in my_list	True تنها در صورتی که i در my_list وجود دارد وگرنه False
i not in my_list	دقیقا برعکس قبلی
my_list + my_another_list	یک لیست یا توپل جدید با چسباندن دو تای داده‌شده می‌سازد
t * n	در صورتی که n عدد صحیح مثبت و t یک توپل یا لیست باشد، یک لیست یا توپل با تکرار کردن t به تعداد n بار می‌سازد
t[i]	گرفتن عنصر i ام از t با شروع از ۰. در صورتی که i منفی باشد از آخر لیست یا توپل شروع می‌کند
t[i:j]	گرفتن یک قاچ(!) از مخزن.
t[i:j:k]	گرفتن یک قاچ از مخزن اما گرفتن هر k عنصر(قدم‌های k تایی)

چند نمونه از رفتار این عملگر‌ها

>>> my = tuple(range(6))
>>> my
(0, 1, 2, 3, 4, 5)
>>> 0 in my
True
>>> 10 not in my
True
>>> 1 not in my
False
>>> py = (0, 0, 0)
>>> py + my
(0, 0, 0, 0, 1, 2, 3, 4, 5)
>>> my + py
(0, 1, 2, 3, 4, 5, 0, 0, 0)
>>> my * 3
(0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5)
>>> my[0]
0
>>> my[1:3]
(1, 2)
>>> my[1:3:2]
(1,)
>>> ly = list(range(100))
>>> ly[50:90:10]
[50, 60, 70, 80]

تعداد اعضا، بیشینه و کمینه

سه تابع len،max و min تعداد اعضای یک مخزن،بزرگترین عضو مخزن و کوچکترین عضو مخزن را برمیگردانند. توابع بیشینه و کمینه یک آرگامون اختیاری key هم می‌توانند دریافت کنند که مانند متد sort لیست عمل می‌کند.

>>> my_tuple = (1,2,3,4,10,20,2)
>>> len(my_tuple)
7
>>> max(my_tuple)
20
>>> min(my_tuple)
1

منابع و مطالعه بیشتر

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