جلسه هفتم دوره پایتون – لیست ها در پایتون و توابع آن

مقدمه

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

• جلسه اول دوره پایتون –  آشنایی با پایتون و ویژگی های آن
• جلسه دوم دوره پایتون- نصب پایتون
• جلسه سوم دوره پایتون- روش های اجرای برنامه پایتون
• جلسه چهارم دوره پایتون- متغیرها در پایتون
• جلسه پنجم دوره پایتون – بررسی نوع داده های عددی
• جلسه ششم دوره  – رشته ها در پایتون 

معرفی لیست ها در Python

لیست های (به انگلیسی List) یکی از انواع داده های پرکاربرد در پایتون است و ما زیاد با این نوع داده برخورد خواهیم کرد. به زبان ساده منظور از لیست یک سری نوع داده ( مثل عدد ، رشته  و …) هستند که در کنار یک دیگر قرار گرفته اند. البته مفهوم لیست یک مفهوم کلی است. مثلا وقتی ما یک مجموعه از کارها را کنار هم میگذاریم و میگوییم از ساعت 8 تا 10 کلاس بروم ، سپس از 10 تا 12 درس بخوام. از 12 تا 1 ناهار بخورم ، در واقع یک لیست از کارهای خود را تهیه کرده ایم. لیست ها در برنامه نویسی هم دقیقا به همین شکل ساده هستند. نکته ای که وجود دارد این است که در مثال بالا کارها باید با همین ترتیب انجام شوند. یعنی نمی توان جای کارها را با یکدیگر عوض کرد. در برنامه نویسی نیز یک لیست همین ویژگی را دارد. 

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

در پایتون می توان یک لیست را با قرار دادن انواع داده های مورد نظر درون یک کروشه (منظور [] است.)  قرار دادن و آنها را به وسیله کاما (,) از یکدیگر جدا کرد. توجه داشته باشید که درون این کروشه یا براکت میتواند هر نوع داده ای ( مثل int یا float یا string ) قرار داد. در زیر مثالی از چند لیست آورده شده است: 

# empty list
my_list = []

# list of integers
my_list = [1, 2, 3]

# list with mixed datatypes
my_list = [1, "Hello", 3.4]

البته در داخل یک لیست میتواند یک لیست دیگر نیز تعریف شود. به این نوع لیست ، لیست تو در تو گفته می شود. مثال زیر نمونه ای از یک لیست تو در تو ( به انگلیسی nested list ) می باشد: 

# nested list
my_list = ["mouse", [8, 4, 6], ['a']]

دسترسی به المان های یک لیست

راه های مختلفی برای دسترسی به المان های یک لیست وجود دارد. 

راه اول این است که از عملگر index ( که با علامت [] مشخص می شود ) استفاده کنیم. Index یک لیست از 0 شروع می شود. بنابراین لیستی که دارای 5 عضو است ، Index آن از 0 تا 4 می باشد. 

اگر ما تلاش کنیم که به یک عنصری که  Index آن بیشتر از محدوده Index لیست است ، دسترسی داشته باشیم ، در این صورت با خطای IndexError رو برو می شویم. همچنین مقدار Index یک عدد صحیح است و نمی تواند یک عدد اعشاری و یا یک رشته باشد. اگر Index چیزی جز یک عدد صحیح باشد ، در این صورت با خطای TypeError روبرو خواهیم شد. 

در Nested list ها برای دسترسی به عناصر از Index ها تودرتو استفاده میکنیم. در ادامه مثال هایی از دسترسی به عناصر یک لیست آورده می شود:

کد زیر را در نظر بگیرید: 

my_list = ['p','r','o','b','e']
# Output: p
print(my_list[0])

# Output: o
print(my_list[2])

# Output: e
print(my_list[4])

# Error! Only integer can be used for indexing
# my_list[4.0]

# Nested List
n_list = ["Happy", [2,0,1,5]]

# Nested indexing

# Output: a
print(n_list[0][1])    

# Output: 5
print(n_list[1][3])

در صورتی که کد بالا را اجرا کنیم ، خروجی به صورت زیر خواهد بود: 

p
o
e
a
5

Index گذاری منفی:  پایتون به ما این اجازه را می دهد که Index ها خود راعددی منفی بگذاریم. در این صورت اگر Index را برابر 1- قرار دهیم میتوانیم به آخرین عنصر لیست دسترسی داشته باشیم. از 2- قرار دهیم به یکی مانده به آخرین عضو دسترسی خواهیم داشت و … . مثالی از این موضوع در زیر اورده شده است :

my_list = ['p','r','o','b','e']

# Output: e
print(my_list[-1])

# Output: p
print(my_list[-5])

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

ما میتوانیم به کمک عملگر دو نقطه (:) به بخشی از یک لیست نیز دسترسی داشته باشیم: 

my_list = ['r','o','b','o','u','a','v','i','r']
# elements 3rd to 5th
print(my_list[2:5])

# elements beginning to 4th
print(my_list[:-5])

# elements 6th to end
print(my_list[5:])

# elements beginning to end
print(my_list[:])

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

['b', 'o', 'u']
['r', 'o', 'b', 'o']
['a', 'v', 'i', 'r']
['r', 'o', 'b', 'o', 'u', 'a', 'v', 'i', 'r']

همانطور که می بینید ، آنقدر همه چیز ساده است که نیازی به توضیحات اضافی وجود ندارد. 

تغییر اعضای یک لیست و اضافه کردن عضوی به آن

به کمک عملگر مساوی (=) می توانیم عضو و یا اعضایی از یک لیست را تغییر داد.  مثال زیر را در نظر بگیرید:

# mistake values
odd = [2, 4, 6, 8]

# change the 1st item    
odd[0] = 1            

# Output: [1, 4, 6, 8]
print(odd)

# change 2nd to 4th items
odd[1:4] = [3, 5, 7]  

# Output: [1, 3, 5, 7]
print(odd)     

در مثال بالا ابتدا اولین عضو ( یعنی عضوی با Index صفر) را تغییر داده ایم. در گام بعد مقادیر اعضایی با index هایی از 1 تا 4 ( یعنی اعضای 2 و 3 و 4 ) را تغییر داده ایم و سپس آن ها را چاپ کرده ایم. در صورت اجرای این کد نتیجه خروجی به صورت زیر است : 

[1, 4, 6, 8]
[1, 3, 5, 7]

علاوه بر آن به کمک توابع append و extend میتوانیم یک عضو و یا چند عضو را به یک لیست اضافه کنیم. مثال زیر را ببینید:

odd = [1, 3, 5]

odd.append(7)

# Output: [1, 3, 5, 7]
print(odd)

odd.extend([9, 11, 13])

# Output: [1, 3, 5, 7, 9, 11, 13]
print(odd)

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

علاوه بر موارد بالا برای چسباندن دو لیست می توانیم از عملگر + استفاده کنیم.  همچنین برای تکرار یک لیست می توانیم از عملگر * استفاده کنیم. در مثال زیر مثال هایی از این دو عملگر آورده شده است : 

odd = [1, 3, 5]

# Output: [1, 3, 5, 9, 7, 5]
print(odd + [9, 7, 5])

#Output: ["re", "re", "re"]
print(["re"] * 3)

همچنین می توانیم به کمک تابع insert یک المان خاص را در مکانی دلخواه قرار دهیم . مثال زیر را ببینید: 

odd = [1, 9]
odd.insert(1,3)

# Output: [1, 3, 9] 
print(odd)

حذف اعضای یک لیست

با استفاده از کلمه کلیدی del میتوانیم یک عضو یا بخشی از یک لیست و یا حتی کل یک لیست را حذف کنیم.  مثال زیر گویای همه چیز است : 

my_list = ['p','r','o','b','l','e','m']

# delete one item
del my_list[2]

# Output: ['p', 'r', 'b', 'l', 'e', 'm']     
print(my_list)

# delete multiple items
del my_list[1:5]  

# Output: ['p', 'm']
print(my_list)

# delete entire list
del my_list       

# Error: List not defined
print(my_list)

نتیجه اجرای کد بالا به صورت زیر است : 

['p', 'r', 'b', 'l', 'e', 'm']
['p', 'm']

Traceback (most recent call last):
  File "<stdin>", line 19, in <module>
    print(my_list)
NameError: name 'my_list' is not defined

همچنین به کمک تابع remove می توانیم یک عنصر از یک لیست را حذف کنیم. علاوه بر آن میتوانیم یک عضو از یک لیست را از لیست برداریم و آن را به عنوان خروجی برگردانیم. ورودی تابع remove ، دقیقا یکی از اعضای لیست است در حالی که ورودی تابع pop اندیس یکی از اعضای لیست است و در صورتی که اندیسی برای تابع pop قرار ندهیم به صورت پیش فرض آخرین عضو را از لیست بر میدارد و به عنوان خروجی برمیگرداند. 

علاوه بر توابع pop و remove ، میتوانیم از تابع clear نیز استفاده کنیم تا یک لیست را خالی کنیم. در زیر مثال هایی از این توابع آورده شده است: 

my_list = ['p','r','o','b','l','e','m']
my_list.remove('p')

# Output: ['r', 'o', 'b', 'l', 'e', 'm']
print(my_list)

# Output: 'o'
print(my_list.pop(1))

# Output: ['r', 'b', 'l', 'e', 'm']
print(my_list)

# Output: 'm'
print(my_list.pop())

# Output: ['r', 'b', 'l', 'e']
print(my_list)

my_list.clear()

# Output: []
print(my_list)

نتیجه خروجی کد بالا به صورت زیر خواهد بود: 

['r', 'o', 'b', 'l', 'e', 'm']
o
['r', 'b', 'l', 'e', 'm']
m
['r', 'b', 'l', 'e']
[]
['r', 'o', 'b', 'l', 'e', 'm']
o
['r', 'b', 'l', 'e', 'm']
m
['r', 'b', 'l', 'e']
[]

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

>>> my_list = ['p','r','o','b','l','e','m']
>>> my_list[2:3] = []
>>> my_list
['p', 'r', 'b', 'l', 'e', 'm']
>>> my_list[2:5] = []
>>> my_list
['p', 'r', 'm']

ساخت یک لیست با روش List Comprehension

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

pow2 = [2 ** x for x in range(10)]

# Output: [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
print(pow2)

در مثال بالا می خواهیم توان 2 های عدد x را برای x هایی از 1 تا 10 ( یعنی اعداد 0 و 1 و 2 و 3 و4 و5 و6 و 7 و8 و 9) در یک لیست قرار دهیم. (در ادامه با کلمه کلیدی Range آشنا می شویم ولی فعلا آن را بپذیرید). در این مثال ابتدا 2 به توان صفر رسیده است و به عنوان اولین عضو یک لیست قرار گرفته است. سپس 2 به توان 1 رسیده است و به عنوان دومین عضو از یک لیست قرار گرفته است و … .نتیجه اجرای کد بالا به صورت زیر است : 

[1, 2, 4, 8, 16, 32, 64, 128, 256, 512]

حتی میتوانیم لیست های خود را کمی شخصی سازی کنیم و فیلترهایی را بر روی آن اعمال کنیم. مثل شروطی را بر روی آن قرار دهیم. مثال های زیر را ببینید: ( سعی کنید مثال های زیر را خودتان تحلیل کنید. )

>>> pow2 = [2 ** x for x in range(10) if x > 5]
>>> pow2
[64, 128, 256, 512]
>>> odd = [x for x in range(20) if x % 2 == 1]
>>> odd
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> [x+y for x in ['Python ','C '] for y in ['Language','Programming']]
['Python Language', 'Python Programming', 'C Language', 'C Programming']

به روش بالا برای ساخت یک لیست ، List Comprehension گفته می شود. 

چک کردن اعضای یک لیست

با استفاده از کلمه کلیدی in و not in چک میکنیم که آیا یک حرف یا عدد یا … عضو یک لیست است یا خیر. مثال های زیر را ببینید: 

my_list = ['p','r','o','b','l','e','m']

# Output: True
print('p' in my_list)

# Output: False
print('a' in my_list)

# Output: True
print('c' not in my_list)

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