آشنایی با نحوه ی دسترسی به محتوای لیست ها در زبان برنامه نویسی پایتون

[سیده آمین ارمان]

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

>>> listA = [1, 2, 3, 4, 5]
>>> print(listA)
[1, 2, 3, 4, 5]
>>>
با این وجود، عموماً این سطح از دسترسی مطلوب نیست و ما می خواهیم به تک تک اعضای درون لیست به صورت جداگانه یی دسترسی داشته باشیم. برای این منظور کافی است به صورت زیر عمل کنیم:

>>>print(listA[0])
1
همان طور که در کد بالا می بینید، برای چاپ اولین عضو لیست ابتدا شناسه ی لیست که listA است را می آوریم و بلافاصله بعد از آن درون کروشه اندیس عضو مورد نظر خود که 0 است را قرار می دهیم. خروجی این دستور عضو اول لیست است.

نکته
همواره مد نظر داشته باشیم که در اکثر زبان های برنامه نویسی -من جمله پایتون- شمارش لیست ها، آرایه ها و ... از 0 آغاز می شود.
به همین ترتیب می توانیم به تمام اعضای لیست با استفاده از اندیس های آن ها به صورت جداگانه دسترسی پیدا کنیم:

>>> listA[1]
2
>>> listA[2]
3
>>> listA[3]
4
>>> listA[4]
5
در مثال بالا listA پنج عضو دارد بنابراین اندیسی که به اعضای آن داده می شود در بازه ی 0 تا 4 قرار می گیرد. در این شرایط اگر از مفسر پایتون بخواهیم عضوی با اندیس بیش تر از 4 را به ما نشان دهد با خطای زیر مواجه خواهیم شد:

>>> listA[5]
Traceback (most recent call last):
File "<pyshell#14>", line 1, in
listA[5]
IndexError: list index out of range
در خط آخر، مفسر پایتون به ما نشان می دهد که اندیس استفاده شده در این دستور در دامنه ی مجاز قرار نمی گیرد؛ به عبارت دیگر هیچ عضوی در این لیست با چنین اندیسی وجود ندارد. حال فرض کنید بخواهیم همزمان به زیر مجموعه ای از اعضای یک لیست دسترسی داشته باشیم که بیش تر از یک عضو را شامل می شود ولی تمام اعضای آن را در برنمی گیرد. برای این کار از بازه ای از اندیس ها که زیر مجموعه ی کل اندیس ها است استفاده می کنیم. برای مثال فرض کنید در listA بخواهیم اعضایی که اندیس 1 تا 3 دارند را مشخص کنیم. برای این کار از دستور زیر استفاده می کنیم:

>>> listA[1:4]
[2, 3, 4]
همان طور که می بینید، در دستور بالا از الگویی به شکل [listName[i:j استفاده کرده ایم. i نشان دهنده ی اندیس اولین عضوی از لیست است که می خواهیم به آن دسترسی داشته باشیم که در این جا برابر با 1 است و j هم عددی است که یک واحد بیش تر از اندیس آخرین عضوی از لیست است که می خواهیم آن را نمایش دهیم که در این جا چون می خواهیم عضوی را که اندیس آن 3 است به عنوان آخرین عضو در نظر بگیریم، از عدد 4 به جای j استفاده می کنیم. به عبارت دیگر، با استفاده از این الگو به اعضایی از لیست که اندیس آن ها بزرگ تر یا مساوی i و کوچک تر از j است دسترسی پیدا می کنیم. حال مثال زیر را در نظر بگیرید:

>>> listA[2:]
[3, 4, 5]
در این دستور از الگوی [:listName[i استفاده کرده ایم تا اعضایی از listA را که اندیس آن ها بزرگ تر یا مساوی i که در این جا برابر با 2 است را پیدا کنیم. حال برای دسترسی به اعضایی از listA که اندیس آن ها کوچک تر از عدد 3 باشد دستوری را به صورت زیر وارد می کنیم:

>>> listA[:3]
[1, 2, 3]
همان طور که می بینید در دستور بالا از الگوی [listName[:j استفاده کرده ایم تا به اعضایی از لیست را که اندیس آن ها کوچک تر از عدد صحیح j و نه مساوی با آن است دسترسی داشته باشیم.

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

>>> listA[-1]
5
>>> listA[-2]
4
>>> listA[-3]
3
>>> listA[-4]
2
>>> listA[-5]
1
تاکنون دیدیم که چطور می توانیم به اعضای داخل یک لیست دسترسی پیدا کنیم. حال در نظر بگیرید که بخواهیم عمل ثابتی را روی تک تک اعضای یک لیست انجام دهیم. برای مثال فرض کنید لیستی از وزن های گروهی از ورزشکاران را داریم و می خواهیم بر اساس معیار وزن، آن ها را در سه دسته ی سبک وزن، متوسط، و سنگین وزن تقسیم بندی کنیم. برای این کار لازم است که وزن هر ورزشکار را به صورت جداگانه بررسی کنیم. اگر وزن ورزشکار کم تر 55 کیلوگرم باشد در دسته ی سبک وزن، بین 55 تا 85 در دسته ی متوسط، و بیش تر از 85 کیلوگرم در دسته ی سنگین وزن جای می گیرد. فرض کنیم لیست مورد نظر ما به شکل زیر باشد:

weightList = [['A', 64], ['B', 92], ['C', 49], ['D', 110], ['E', 51], ['F', 73]]
در این جا از لیست های تو در تو استفاده کرده ایم به این شکل که اعضای لیست هر کدام یک لیست هستند که عضو اول آن ها شناسه ی ورزشکار و عضو دوم آن ها وزن ورزشکار است. مثلاً اولین عضو لیست وزن ها، لیستی است که متعلق به ورزشکار A با وزن 64 کیلو گرم است. حال برای آن که بررسی های مورد نظر را برای تک تک ورزشکاران انجام دهیم از یک لوپ for استفاده می کنیم. برای این کار برنامه ای را به شکل زیر می نویسیم:

weightList = [['A', 64], ['B', 92], ['C', 49], ['D', 110], ['E', 51], ['F', 73]]
for item in weightList:
if(item[1] <= 55):
print("Athlete", item[0], "is light-weight.")
elif(55 < item[1] <= 85 ):
print("Athlete", item[0], "is in average weight.")
else:
print("Athlete", item[0], "is heavy-weight.")
پیش از این گفتیم که هر دستور مرکب که با کیورد for آغاز شود در ادامه ی آن نام یک شناسه می آید که در اینجا شناسه ی استفاده شده item است. این متغیر در هر با تکرار لوپ به یکی از اعضای دنباله ای که بعد از کیورد in می آید و در این جا همان لیست weightList است منتسب می شود، در نتیجه در بدنه ی لوپ هر بار یکی از اعضای این لیست مورد بررسی قرار می گیرد. از آن جا که اعضای weightList خود یک لیست هستند متغیر item هر بار به یک لیست با دو عضو منتسب می شود که با دستور [item[0 به عضو اول آن که مشخصه ی ورزشکار و با دستور [item[1 به عضو دوم آن که وزن ورزشکار است دسترسی پیدا می کنیم.

در بدنه ی لوپ for با استفاده از دستورهای شرطی عضو دوم متغیر item یا وزن هر ورزشکار مورد بررسی قرار می گیرد و در صورتی که در هر یک از شرط ها صدق کند پیغام متناسب با آن در خروجی چاپ می شود. برنامه را در فایل ListLoop.py ذخیره و اجرا می کنیم که خروجی آن به شکل زیر خواهد بود:

========== RESTART: C:/SokanAcademy/ListLoop.py ==========
Athlete A is in average weight.
Athlete B is heavy-weight.
Athlete C is light-weight.
Athlete D is heavy-weight.
Athlete E is light-weight.
Athlete F is in average weight.
>>>