کلاس «List» یکی از نوع داده‌های «درونی» (Built-In) و بنیادین در پایتون است. لیست در پایتون ویژگی‌های چشمگیر و مفیدی برای کمک به سازماندهی و مدیریت کارآمد داده‌های ناهمگون دارد. دانش روش کار با لیست در پایتون یکی از مهارت‌های اجباری است که به عنوان توسعه‌دهنده پایتون باید داشته باشیم. لیست‌ها کاربرد بسیار گسترده‌ای دارند. ‌تقریبا در همه پروژه‌های واقعی که با آن‌ها کار می‌کنید به‌صورت متناوبی با لیست‌ها روبه‌رو خواهید شد. با مطالعه این مطلب از مجله فرادرس به‌طور بسیار دقیقی با لیست‌ها آشنا خواهیم شد و به درکی قوی از ویژگی‌های لیست‌ در پایتون می‌رسیم. این دانش به همه برنامه‌نویسان کمک می‌کند با بکارگیری مزایای لیست‌ها برنامه‌های موثرتری بنویسند.

علاوه بر مواردی که در بالا بیان شدند، به کدنویسی مثال‌هایی خواهیم پرداخت که موارد رایج استفاده لیست در پایتون را نمایش می‌دهند. این مثال‌ها کمک می‌کنند که بفهمیم چگونه از لیست‌ها در کدهایمان به شکل بهتری استفاده کنیم. برای اینکه از این مطلب آموزشی بیشترین بهره را ببرید باید درک خوبی از مفاهیم اساسی پایتون شامل «متغیرها» (Variables)، «توابع» (Functions) و حلقه‌ی for داشته باشید. به همین صورت، آشنایی با نوع داده‌های دورنی دیگری همچون «رشته‌ها» (Strings)، «تاپل‌ها» (Tuples)، « دیکشنری‌ها» (Dictionaries) و «مجموعه‌ها» (Sets) نیز کمک می‌کنند درک این مطلب ساده‌تر شود.

 آشنایی با نوع داده لیست در پایتون

لیست‌های پایتون نوع داده‌‌ای «درونی» (Built-In)، منعطف، چندکاره، قدرتمند و پرطرفدار هستند. کمک می‌‌کنند که دنباله‌هایی با طول متغیر و محتوای قابل تغییر از اشیا را ایجاد کنند. در لیست‌ها می‌توانید هر نوعی از اشیا را ذخیره کنید. حتی می‌توانید انواع مختلفی از اشیا و نوع داده‌ها را کنار هم در یک لیست ترکیب کنید، اگرچه عناصر داخل لیست اغلب از یک نوع هستند.

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

چند مورد از مشخصات ‌ظاهری اشیا لیست شامل مواردی می‌شوند که در پایین فهرست کرده‌ایم.

• «منظم» (Ordered): لیست‌ها شامل عناصر یا آیتم‌هایی می‌شوند که پشت سر هم، طبق نظم ورودشان به لیست مرتب شده‌اند.
• «شروع از صفر» (Zero-based): لیست‌ها به کاربران اجازه می‌دهند از طریق ایندکس‌هایی که از صفر شروع می‌شوند به خانه‌های لیست و مقدار درون هر خانه دسترسی داشته باشند.
• «تغییرپذیری» (Mutable): لیست‌ها در پایتون از تغییر در عناصر داخل‌شان پشتیبانی می‌کنند. می‌توانید به‌صورت مستقیم عناصر داخل لیست را حذف، اضافه و به‌روزرسانی کنید.
• «ناهمگونی» (Heterogeneous): می‌توان اشیا مختلفی را در لیست یکسانی ذخیره کرد.
• «قابلیت رشد» (Growable) و «پویایی» (Dynamic): لیست‌های می‌‌توانند به‌صورت خودکار رشد کنند یا کوچک شوند. این امر به معنای این است که از عملیات جمع بستن، اضافه کردن و حذف عناصر پشتیبانی می‌کنند.
• «قابل تودرتو شدن» (Nestable): لیست‌های می‌توانند لیست‌های دیگری را هم در خود جای دهند. یعنی می‌توانیم لیستی از لیست‌ها داشته باشیم.
• «پیمایش‌پذیر» (Iterable): لیست‌ها از پیمایش‌پذیری پشتیبانی می‌کنند. بنابراین هر وقت که بخواهیم عملیاتی را روی تک تک عناصر لیست به‌صورت مجزا اجرا کنیم می‌توانیم روی آن‌ها با کمک حلقه یا روش «Comprehension» پیمایش کنیم.
• «قابلیت تکه‌تکه شدن» (Sliceable): لیست‌ها عملیات مربوط به تکه‌تکه کردن را پشتیبانی می‌کنند. یعنی می‌‌توانیم ردیفی از عناصر را از لیست استخراج کنیم و در لیست جدیدی جای بدهیم.
• «قابل ترکیب شدن» (Combinable): لیست‌ها از عملیات مربوط به چسباندن پشتیبانی می‌کنند. پس می‌توانیم دو یا چند لیست را با عملیات مربوط به چسباندن به هم الحاق کنیم و لیست بزرگتری ایجاد کنیم.
• «قابلیت تکثیر» (Copyable): لیست‌ها اجازه می‌دهند که با استفاده از روش‌های مختلف از روی عناصر محتوی آن‌ها یا خودشان کپی تهیه کنید.

لیست‌ها صفی از اشیا هستند. به‌صورت رایج «ظرف» (Container) یا «مجموعه» (Collection) خوانده می‌شوند. زیرا هر لیست مجزا می‌تواند تعداد نامشخصی از دیگر اشیا را شامل شود یا در خود جمع کند.

به این نکته توجه کنید که لیست در پایتون از مجموعه‌ غنی از عملیاتی پشتیبانی می‌کند که به‌صورت رایجی برای همه انواع صف‌ها مانند «تاپل‌ها» (Tuples)، «رشته‌ها» (Strings) و «رِنج‌ها» (Ranges) بکار می‌روند. این عملیات به عنوان عملیات رایج توالی‌ها شناخته می‌شوند. در طول این مطلب از مجله فرادرس چندین مورد از عملیات رایج توالی‌های مربوط به لیست را یاد خواهید گرفت.

به‌طور خلاصه کار با لیست در پایتون مانند کار با آرایه‌های با اندازه خودکار است که در سایر زبان‌های برنامه نویسی – مثل «بردار» (Vector) در ++C و «لیست-آرایه» (ArrayList) در جاوا – تعریف شده است. لیست در واقع مجموعه‌ای از چیزها است که در بین دو براکت []

 محصور شده‌اند و با کاما ,

 از یکدیگر جدا می‌شوند.

در مثال زیر به‌ساده‌ترین حالت لیست را تعریف کرده‌ایم. می‌توان گفت در واقع با بکار بردن دو براکت []

  به‌صورت کاملا ابتدایی و ساده یک لیست ساخته‌ایم.

1Var = ["Geeks", "for", "Geeks"]
2print(Var)

خروجی کد بالا به‌صورت زیر است.

["Geeks", "for", "Geeks"]

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

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

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

مثال اول ساخت لیست در پایتون

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

1# Python program to demonstrate
2# Creation of List
3
4# Creating a List
5List = []
6print("Blank List: ")
7print(List)
8
9# Creating a List of numbers
10List = [10, 20, 14]
11print("nList of numbers: ")
12print(List)
13
14# Creating a List of strings and accessing
15# using index
16List = ["Geeks", "For", "Geeks"]
17print("nList Items: ")
18print(List[0])
19print(List[2])

خروجی کد بالا به شکل زیر است.

Blank List: 
[]

List of numbers: 
[10, 20, 14]

List Items: 
Geeks
Geeks

مثال دوم ساخت لیست با استفاده از عناصر متمایز و تکراری

لیست‌ها می‌توانند شامل مقادیر تکراری به همراه موقعیت‌های متمایز برای هر کدام باشند. بنابراین چندین مقدار متمایز یا تکراری می‌توانند در یک توالی به‌صورت همزمان برای ایجاد لیست ارسال شوند. به مثالی که در ادامه آورده‌ایم نگاه کنید.

1# Creating a List with
2# the use of Numbers
3# (Having duplicate values)
4List = [1, 2, 4, 4, 3, 3, 3, 6, 5]
5print("nList with the use of Numbers: ")
6print(List)
7
8# Creating a List with
9# mixed type of values
10# (Having numbers and strings)
11List = [1, 2, 'Geeks', 4, 'For', 6, 'Geeks']
12print("nList with the use of Mixed Values: ")
13print(List)

خروجی کد بالا به صورت زیر است.

List with the use of Numbers: 
[1, 2, 4, 4, 3, 3, 3, 6, 5]

List with the use of Mixed Values: 
[1, 2, 'Geeks', 4, 'For', 6, 'Geeks']

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

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

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

مثال اول دسترسی به عناصر درون لیست

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

1# Python program to demonstrate
2# accessing of element from list
3
4# Creating a List with
5# the use of multiple values
6List = ["Geeks", "For", "Geeks"]
7
8# accessing a element from the
9# list using index number
10print("Accessing a element from the list")
11print(List[0])
12print(List[2])

خروجی کد بالا به شکل زیر است.

Accessing a element from the list
Geeks
Geeks

مثال دوم دسترسی به عناصر درون لیست های چندبعدی

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

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

1# Creating a Multi-Dimensional List
2# (By Nesting a list inside a List)
3List = [['Geeks', 'For'], ['Geeks']]
4
5# accessing an element from the
6# Multi-Dimensional List using
7# index number
8print("Accessing a element from a Multi-Dimensional list")
9print(List[0][1])
10print(List[1][0])

خروجی کد بالا به‌صورت زیر است.

Accessing a element from a Multi-Dimensional list
For
Geeks

ایندکس های منفی

برای کار با لیست در پایتون می توانیم از ایندکس‌های منفی هم استفاده کنیم. ایندکس‌های منفی به موقعیت خانه‌های لیست از سمت آخر اشاره می‌کنند. به عنوان مثال به‌جای این‌که مجبور باشیم مقدار عنصر موجود در ایندکس لیست از انتها را با کمک کدی مثل List[len(List)-3]

 محاسبه کنیم، فقط کافی است که کد را به صورت List[-3]

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

 به آخرین عنصر لیست اشاره می‌کند، ایندکس -2

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

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

در ادامه مثالی از استفاده‌ی ایندکس‌های منفی را پیاده‌سازی کرده‌ایم.

1List = [1, 2, 'Geeks', 4, 'For', 6, 'Geeks']
2
3# accessing an element using
4# negative indexing
5print("Accessing element using negative indexing")
6
7# print the last element of list
8print(List[-1])
9
10# print the third last element of list
11print(List[-3])

خروجی کد بالا به‌صورت زیر است.

Accessing element using negative indexing
Geeks
For

پیدا کردن اندازه لیست ها در پایتون

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

 است.

به مثالی که در ادامه از استفاده تابع len()

 زده‌ایم نگاه کنید.

1# Creating a List
2List1 = []
3print(len(List1))
4
5# Creating a List of numbers
6List2 = [10, 20, 14]
7print(len(List2))

خروجی کد بالا به‌صورت زیر است.

0
3

گرفتن ورودی به صورت لیست در پایتون

می‌توانیم اعضای لیست را به‌صورت یکجا در ورودی با نوع داده «رشته» (String)، «عدد صحیح» (Integer)، «عدد اعشاری» (Float) و غیره بگیریم. اما حالت پیش‌فرض نوع داده برای ورودی‌های پایتون، رشته است.

مثال اول لیست با محتویات رشته

مثالی که در ادامه آورده‌ایم درباره دریافت یک رشته و تجزیه کاراکترهای آن برای تشکیل یک لیست است. البته توجه کنید که هر رشته در واقع لیستی از کاراکتر‌ها است. به مثال زیر توجه کنید.

1# Python program to take space
2# separated input as a string
3# split and store it to a list
4# and print the string list
5
6# input the list as string
7string = input("Enter elements (Space-Separated): ")
8
9# split the strings and store it to a list
10lst = string.split() 
11print('The list is:', lst) # printing the list

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

Enter elements: GEEKS FOR GEEKS
The list is: ['GEEKS', 'FOR', 'GEEKS']

مثال دوم گرفتن ورودی به صورت اعداد صحیح

برای اینکه بتوانیم ورودی را به‌صورت اعداد بگیریم، در این مثال از تابع map()

 استفاده کردیم. به مثال آمده در پایین نگاه کنید.

1# input size of the list
2n = int(input("Enter the size of list : "))
3# store integers in a list using map,
4# split and strip functions
5lst = list(map(int, input("Enter the integer
6elements:").strip().split()))[:n]
7
8# printing the list
9print('The list is:', lst) 

خروجی مثال بالا به شکل زیر است.

Enter the size of list : 4
Enter the integer elements: 6 3 9 10
The list is: [6, 3, 9, 10]

اضافه کردن عنصر به لیست در پایتون

یکی از مهم‌ترین وظایف مربوط به کار با لیست در پایتون اضافه کردن عنصر به لیست‌ها است. برای انجام این کار، سه روش کلی وجود دارد. هرکدام از این روش‌ها توسط یکی از متدهای «درونی» (Built-In) پایتون انجام می‌گیرند و کاربردهای خاص مربوط به خود را دارند. این متدها را در ادامه فهرست کرده‌ایم.

1. متد append()
2. متد insert()
3. متد extend()

روش اول استفاده از متد append

با استفاده از تابع درونی append()

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

چند عنصر را به‌صورت جداگانه به لیست وارد کنیم باید از حلقه‌ها استفاده کنیم. به کمک تابع append()

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

اضافه شوند.

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

1# Python program to demonstrate
2# Addition of elements in a List
3
4# Creating a List
5List = []
6print("Initial blank List: ")
7print(List)
8
9# Addition of Elements
10# in the List
11List.append(1)
12List.append(2)
13List.append(4)
14print("nList after Addition of Three elements: ")
15print(List)
16
17# Adding elements to the List
18# using Iterator
19for i in range(1, 4):
20	List.append(i)
21print("nList after Addition of elements from 1-3: ")
22print(List)
23
24# Adding Tuples to the List
25List.append((5, 6))
26print("nList after Addition of a Tuple: ")
27print(List)
28
29# Addition of List to a List
30List2 = ['For', 'Geeks']
31List.append(List2)
32print("nList after Addition of a List: ")
33print(List)

خروجی کد بالا به‌صورت زیر است.

Initial blank List: 
[]

List after Addition of Three elements: 
[1, 2, 4]

List after Addition of elements from 1-3: 
[1, 2, 4, 1, 2, 3]

List after Addition of a Tuple: 
[1, 2, 4, 1, 2, 3, (5, 6)]

List after Addition of a List: 
[1, 2, 4, 1, 2, 3, (5, 6), ['For', 'Geeks']]

روش دوم استفاده از تابع insert

متد append()

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

 استفاده کنیم. برعکس متد append()

که فقط یک آرگومان می‌گیرد، متد insert()

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

1# Python program to demonstrate 
2# Addition of elements in a List
3
4# Creating a List
5List = [1,2,3,4]
6print("Initial List: ")
7print(List)
8
9# Addition of Element at 
10# specific Position
11# (using Insert Method)
12List.insert(3, 12)
13List.insert(0, 'Geeks')
14print("nList after performing Insert Operation: ")
15print(List)

خروجی کد بالا به‌صورت زیر است.

Initial List: 
[1, 2, 3, 4]

List after performing Insert Operation: 
['Geeks', 1, 2, 3, 12, 4]

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

روش سوم استفاده از متد extend

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

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

به این نکته توجه کنید که متد‌های extend()

 و append()

 آرگومان‌های گرفته‌ را می‌توانند فقط به انتهای لیست اضافه کنند. به کد پیاده‌سازی شده در پایین برای نمایش نحوه کار این متد توجه کنید.

1# Python program to demonstrate
2# Addition of elements in a List
3
4# Creating a List
5List = [1, 2, 3, 4]
6print("Initial List: ")
7print(List)
8
9# Addition of multiple elements
10# to the List at the end
11# (using Extend Method)
12List.extend([8, 'Geeks', 'Always'])
13print("nList after performing Extend Operation: ")
14print(List)

خروجی که از اجرای کد بالا تولید می‌شود به‌صورت زیر است.

Initial List: 
[1, 2, 3, 4]

List after performing Extend Operation: 
[1, 2, 3, 4, 8, 'Geeks', 'Always']

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

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

• متد reverse()
• تابع reversed()

در ادامه به بررسی این دو تابع ظاهرا شبیه به یکدیگر می‌پردازیم.

روش اول متد reverse

در این روش متد reverse()

برای معکوس کردن لیستی استفاده می‌شود که قبل از متد نام‌برده شده. متد reverse()

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

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

1# Reversing a list
2mylist = [1, 2, 3, 4, 5, 'Geek', 'Python']
3mylist.reverse()
4print(mylist)

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

['Python', 'Geek', 5, 4, 3, 2, 1]

استفاده از تابع reversed

تابع reversed()

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

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

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

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

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

1my_list = [1, 2, 3, 4, 5]
2reversed_list = list(reversed(my_list))
3print(reversed_list)

خروجی کد بالا به‌صورت زیر است.

[5, 4, 3, 2, 1]

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

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

• متد remove()
• متد pop()

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

استفاده از متد remove

با استفاده از تابع درونی remove()

می‌توان عناصر داخل لیست را حذف کرد اما اگر عنصری درون لیست وجود نداشته باشد باعث ایجاد خطا خواهد شد. متد remove()

در هر بار اجرا فقط یک عنصر را می‌تواند حذف کند. برای اینکه بتوانیم چندین عنصر مختلف را با استفاده از این تابع حذف کنیم باید از یکی از انواع حلقه‌ها برای پیمایش روی لیست استفاده کنیم. متد remove()

فقط عنصری را حذف می‌کند که از قبل مشخص شده است.

به این نکته توجه کنید که متد remove()

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

به مثالهایی که در ادامه از نحوه کار متد remove()

زده شده نگاه کنید.

مثال اول

در مثال زیر اعمال مستقیم متد remove()

را بر روی عنصرهای مشخص شده می‌بینیم.

1# Python program to demonstrate
2# Removal of elements in a List
3
4# Creating a List
5List = [1, 2, 3, 4, 5, 6,
6		7, 8, 9, 10, 11, 12]
7print("Initial List: ")
8print(List)
9
10# Removing elements from List
11# using Remove() method
12List.remove(5)
13List.remove(6)
14print("nList after Removal of two elements: ")
15print(List)

خروجی کد بالا به شکل زیر است.

Initial List: 
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

List after Removal of two elements: 
[1, 2, 3, 4, 7, 8, 9, 10, 11, 12]

مثال دوم

در این مثال استفاده از متد remove()

را به کمک حلقه بر روی لیست می‌بینیم. برای حذف چند عصر مختلف توسط متد remove()

باید از حلقه‌ها استفاده کرد.

1# Creating a List
2List = [1, 2, 3, 4, 5, 6,
3		7, 8, 9, 10, 11, 12]
4# Removing elements from List
5# using iterator method
6for i in range(1, 5):
7	List.remove(i)
8print("nList after Removing a range of elements: ")
9print(List)

نتیجه اجرای کد بالا به‌صورت زیر نمایش داده می‌شود.

List after Removing a range of elements: 
[5, 6, 7, 8, 9, 10, 11, 12]

استفاده از متد pop

از متد pop()

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

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

ارسال کنیم.

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

 توجه کنید.

1List = [1, 2, 3, 4, 5]
2
3# Removing element from the
4# Set using the pop() method
5List.pop()
6print("nList after popping an element: ")
7print(List)
8
9# Removing element at a
10# specific location from the
11# Set using the pop() method
12List.pop(2)
13print("nList after popping a specific element: ")
14print(List)

خروجی کد بالا به‌صورت زیر است.

List after popping an element: 
[1, 2, 3, 4]

List after popping a specific element: 
[1, 2, 4]

عملیات Slicing بر روی لیست

با استفاده از قطعات مختلف لیست‌ها می‌توانیم زیررشته یا زیرلیست‌های مختلفی را بدست بیاوریم. در زمان کار با لیست در پایتون راه‌های مختلفی برای نمایش کل لیست با همه عنصرهایش به کاربران وجود دارند. اما برای اینکه فقط قسمت خاصی از لیست را نمایش دهیم یا برای مصارف گوناگون از لیست جدا کنیم از «عملیات قطعه قطعه کردن» (Slicing Operation) استفاده می‌کنیم.

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

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

[: Index]

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

[:-Index]

برای اینکه عنصرهای مورد نظرمان را در لیست از ایندکس خاصی تا انتهای لیست جدا کنیم، از تکه کد زیر استفاده می‌کنیم.

[Index:]

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

[::-1]

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

مثال هایی برای درک برش های لیست

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

• pr[0]

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

• pr[-4]

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

• pr[2:]

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

• pr[:4]

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

• pr[2:4]

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

• pr[1::2]

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

در واقع برای اجرای Slicing Operation لیست را به‌صورت [a : b : c]

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

• a: ایندکس نقطه شروع محدوده دسترسی را نشان می‌دهد.
• b: ایندکس آخرین محدوده دسترسی بعلاوه یک، زیرا در پیمایش لیست‌ها پارامتر دوم به عنوان حد بیرون محدوده شناخته می‌شود. البته توجه کنید که لیست‌ها از صفر ایندکس‌گذاری می‌شوند.
• c: تعداد گام‌های پیمایش که به‌صورت پیش فرض یک است.

به کدی که در ادامه پیاده‌سازی کرده‌ایم نگاه کنید.

1# Python program to demonstrate
2# Removal of elements in a List
3
4# Creating a List
5List = ['G', 'E', 'E', 'K', 'S', 'F',
6		'O', 'R', 'G', 'E', 'E', 'K', 'S']
7print("Initial List: ")
8print(List)
9
10# Print elements of a range
11# using Slice operation
12Sliced_List = List[3:8]
13print("nSlicing elements in a range 3-8: ")
14print(Sliced_List)
15
16# Print elements from a
17# pre-defined point to end
18Sliced_List = List[5:]
19print("nElements sliced from 5th "
20	"element till the end: ")
21print(Sliced_List)
22
23# Printing elements from
24# beginning till end
25Sliced_List = List[:]
26print("nPrinting all elements using slice operation: ")
27print(Sliced_List)

خروجی کد بالا به‌صورت زیر است.

Initial List: 
['G', 'E', 'E', 'K', 'S', 'F', 'O', 'R', 'G', 'E', 'E', 'K', 'S']

Slicing elements in a range 3-8: 
['K', 'S', 'F', 'O', 'R']

Elements sliced from 5th element till the end: 
['F', 'O', 'R', 'G', 'E', 'E', 'K', 'S']

Printing all elements using slice operation: 
['G', 'E', 'E', 'K', 'S', 'F', 'O', 'R', 'G', 'E', 'E', 'K', 'S']

استفاده از ایندکس منفی

در بخش‌های قبلی درباره اثر ایندکس منفی در لیست‌ها صحبت کرده‌ایم. در کد زیر مثالی از جدا کردن قطعات مختلف از لیست با استفاده از ایندکس منفی را پیاده‌سازی می‌کنیم.

1# Creating a List
2List = ['G', 'E', 'E', 'K', 'S', 'F',
3		'O', 'R', 'G', 'E', 'E', 'K', 'S']
4print("Initial List: ")
5print(List)
6
7# Print elements from beginning
8# to a pre-defined point using Slice
9Sliced_List = List[:-6]
10print("nElements sliced till 6th element from last: ")
11print(Sliced_List)
12
13# Print elements of a range
14# using negative index List slicing
15Sliced_List = List[-6:-1]
16print("nElements sliced from index -6 to -1")
17print(Sliced_List)
18
19# Printing elements in reverse
20# using Slice operation
21Sliced_List = List[::-1]
22print("nPrinting List in reverse: ")
23print(Sliced_List)

خروجی کد بالا به‌صورت زیر است.

Initial List: 
['G', 'E', 'E', 'K', 'S', 'F', 'O', 'R', 'G', 'E', 'E', 'K', 'S']

Elements sliced till 6th element from last: 
['G', 'E', 'E', 'K', 'S', 'F', 'O']

Elements sliced from index -6 to -1
['R', 'G', 'E', 'E', 'K']

Printing List in reverse: 
['S', 'K', 'E', 'E', 'G', 'R', 'O', 'F', 'S', 'K', 'E', 'E', 'G']

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

تعریف لیست به روش Comprehension

برای کار با لیست در پایتون باید روش «Comprehension» را بشناسیم. روش Comprehension ، یکی از روش‌های بسیار عالی ساخت لیست به کمک هر شی پیمایش‌پذیر موجود است. Comprehension یکی از ابزارهای بنیادین تبدیل اشیا پیمایش‌پذیر به لیست است. این ابزار به ساخت لیست با استفاده از داده‌های تغییر شکل یافته سایر اشیا پیمایش‌پذیر، شامل لیست‌ها، تاپل‌ها، رشته‌ها و غیره کمک می‌کند.

سینتکس عملیات List Comprehension

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

1[expression for item in list if condition == True]

می‌توانیم سینتکس بالا را به این صورت بخوانیم که برای هر آیتمی item

 در لیست list

 ، دستور expression

 اجرا شود اگر if

 شرط برقرار باشد True

 . توجه کنید که وجود بخش مربوط به شرط if

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

مثالی برای List Comprehension

برای اینکه درک کنیم که چگونه Comprehension-ها می‌توانند به تغییر داده‌ها برای ایجاد لیست کمک کنند به مثالی اشاره می‌کنیم. در این مثال لیستی از کاراکترهای ارقام با نوع داده رشته داریم و می‌خواهیم این کاراکتر‌های رقمی را به عددهای واقعی تبدیل کنیم. برای حل این مشکل از Comprehension به شکلی کدنویسی شده در پایین استفاده می‌کنیم.

1numbers = ["2", "9", "5", "1", "6"]
2
3numbers = [int(number) for number in numbers]
4numbers

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

[2, 9, 5, 1, 6]

برای اجرای عملیات Comprehension باید از شی پیمایش‌پذیری به‌عنوان مرجع استفاده کرد. در کد بالا از لیست دیگری به عنوان مرجع Comprehension استفاده کردیم. این Comprehension روی همه مقادیر لیستی پیمایش می‌کند که به عنوان مرجع به‌صورت پارامتر دریافت کرده است. عبارت تعریف شده درون این Comprehension عملیات تبدیل را از رشته به نوع داده «عدد صحیح» (Integer) انجام می‌دهد. نتیجه نهایی، شی جدیدی از کلاس لیست است که با نام numbers تعریف کرده‌ایم. در واقع این نام متعلق به لیست قبلی بود و با الصاق به لیست جدید لیست قبلی از دسترس خارج می‌شود.

حلقه for در مقابل List Comprehension

اجرای عملیات Comprehension کد را نسبت به حلقه for

 کوتاه‌تر و شفاف‌تر می‌کند. توجه داشته باشید که این Comprehension معادل استفاده از حلقه for

 در کنار تابع enumerate()

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

1numbers = ["2", "9", "5", "1", "6"]
2
3for i, number in enumerate(numbers):
4    numbers[i] = int(number)
5
6
7numbers

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

[2, 9, 5, 1, 6]

برای حل چنین مسائلی استفاده از حلقه بسیار پیچیده‌تر است و کدنویسی بیشتری نیاز دارد. زیرا باید تابع enumerate()

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

به عنوان نمونه بعدی، فرض کنید لیستی از اعداد داریم. می‌خواهیم برنامه‌ای بنویسیم که مربع هر کدام از عناصر لیست را چاپ کند. برای این کار برنامه را به دو روش، یعنی یکبار با استفاده از حلقه for و بار دیگر با روش Comprehension می‌نویسیم.

در کد آمده زیر برنامه را با کمک حلقه for

 نوشته‌ایم.

1numbers = [1, 2, 3, 4, 5]
2square_numbers = []
3
4# for loop to square each elements
5for num in numbers:
6    square_numbers.append(num * num)
7    
8print(square_numbers)
9
10# Output: [1, 4, 9, 16, 25]

خروجی کد بالا در خط آخر کد به‌صورت کامنت نمایش داده شده است.

دفعه دوم، برنامه را با استفاده از روش List Comprehension می‌نویسیم.

1numbers = [1, 2, 3, 4, 5]
2
3# create a new list using list comprehension
4square_numbers = [num * num for num in numbers]
5
6print(square_numbers)
7
8# Output: [1, 4, 9, 16, 25]

وقتی که روش کار حلقه for

 را در پایتون یادبگیرید، درک سینتکس و روش استفاده از List Comprehension بسیار آسانتر می‌شود.

استفاده از شرط در List Comprehension

یکی از استفاده‌های دیگر Comprehension فیلتر کردن لیست‌های موجود است. می‌توانیم از عبارت شرطی if…else

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

برای نمونه، مثالی از بکار بردن عبارت شرطی if

 را در عملیات Comprehension می‌بینیم.

1# filtering even numbers from a list
2even_numbers = [num for num in range(1, 10) if num % 2 == 0 ]
3
4print(even_numbers)

خروجی کد بالا به‌صورت زیر است.

[2, 4, 6, 8]

در مثال بالا عملیات Comprehension به دنبال اعداد زوج در range(1, 10)

 می‌گردد، هر عدد زوجی را که پیدا کرد به لیست even_numbers

 وارد می‌کند. توجه کنید که تابع range()

 برای تولید صفی از اعداد بکار می‌رود.

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

1integers = [20, 31, 52, 6, 17, 8, 42, 55]
2
3even_numbers = [number for number in integers if number % 2 == 0]
4even_numbers

خروجی کد بالا به‌صورت زیر است.

[20, 52, 6, 8, 42]

بند مربوط به if

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

سعی کنید برای خودتان Comprehension بنویسید که اعداد فرد را جدا کند.

سوالات متداول

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

لیست های پایتون چه هستند؟

لیست‌ها نوع خاصی از ساختار داده در پایتون هستند که می‌توانند به‌صورت منظمی عناصر یا آیتم‌هایی از هر نوع داده‌ی ممکن در پایتون را ذخیره کنند.

سینتکس لازم برای نوشتن لیست ها در پایتون چیست؟

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

لیست ها چگونه در پایتون کار می کنند؟

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

جمع بندی

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

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

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

• با استفاده از روش‌ها مختلف به ایجاد لیست در پایتون پرداختیم.
• روش دسترسی به آیتم‌های موجود در لیست را بررسی کردیم.
• انجام عملیات تکثیر، به‌روزرسانی، رشد، کوتاه کردن و چسباندن لیست‌های موجود به یکدیگر را با روش‌های مختلف آموختیم.
• منظم کردن، برعکس کردن و پیمایش لیست‌های موجود را با کمک متدها و توابع «درونی» (Built-In) پایتون یاد گرفتیم.
• استفاده از دیگر ویژگی‌های اختصاصی لیست‌ها را تمرین کردیم.

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