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

معرفی

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

اما لیست دقیقاً چیست؟ یک لیست در هسته خود مجموعه ای از عناصر (اعم از اعداد، رشته ها، اشیاء یا حتی سایر ساختارهای داده) را نشان می دهد که در یک روش خطی، جایی که هر عنصر موقعیت خاصی دارد.

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

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

مبانی ساختار داده فهرست

قبل از اینکه به پیاده سازی ساختار داده لیست توسط پایتون بپردازیم، بیایید اصول اولیه را از سر راه برداریم.

فهرست چیست؟

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

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

ویژگی های لیست ها

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

در صورت شناخت هر عنصر موجود در لیست می توانید به آن دسترسی داشته باشید فهرست مطالب. در اصل، یک شاخص عددی است که نشان دهنده مکان عنصر در لیست است. شروع یک لیست با شاخص نشان داده می شود 0، عنصر دوم دارای شاخص است 1، و غیره روی.

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

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

انواع لیست ها: آرایه ها در مقابل لیست های پیوندی

به طور کلی، دنیای فهرست ها را می توان به دو نوع اصلی طبقه بندی کرد روی اجرای اساسی آنها – آرایه ها و لیست های مرتبط.

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

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

مبانی لیست های پایتون

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

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

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

numbers = (1, 2, 3, 4, 5)
cars = ('chevrolet', 'ford', 'gmc')
mixed_data = (2, 'hello', 3.14, True)

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

empty_list = list()

string_to_list = list('hello')

tuple_to_list = list((1, 2, 3))

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

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

cars = ('chevrolet', 'ford', 'gmc')
print(cars(0))  
print(cars(1))  

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

cars = ('chevrolet', 'ford', 'gmc')
print(cars(-1))  
print(cars(-2))  

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

numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
first_five = numbers(:5)      
last_five = numbers(-5:)      
middle = numbers(3:7)         

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

عملیاتی که می توانید انجام دهید روی لیست ها در پایتون

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

این append() متد به شما امکان می دهد a را اضافه کنید عنصر واحد تا انتهای لیست:

cars = ('chevrolet', 'ford', 'gmc')
cars.append('cadillac')
print(cars)  

این insert() متد شما را قادر می سازد تا یک عنصر را در a وارد کنید شاخص خاص در لیست، عناصر موجود را به سمت راست منتقل کنید:

cars = ('chevrolet', 'ford', 'gmc')
cars.insert(1, 'cadillac')
print(cars)  

این extend() روش برای الحاق استفاده می شود عناصر متعدد به یک لیست یک تکرارپذیر مانند لیست، چند تا یا رشته دیگر را به عنوان آرگومان its_ می گیرد و عناصر آن را اضافه می کند. تا پایان از لیست اصلی:

cars = ('chevrolet', 'ford', 'gmc')
cars.extend(('cadillac', 'buick'))
print(cars)  

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

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

cars = ('chevrolet', 'ford', 'gmc')
cars.remove('ford')
print(cars)  

این pop() متد عنصر را در a حذف کرده و برمی گرداند شاخص مشخص شده:

cars = ('chevrolet', 'ford', 'gmc')
cars.pop(1)
print(cars)  

cars.pop()
print(cars)  

این del کلمه کلیدی برای حذف یک عنصر یا تکه ای از عناصر از یک لیست استفاده می شود با شاخص آن:

cars = ('chevrolet', 'ford', 'gmc')
del cars(1)
print(cars)  

del cars(0:2)
print(cars)  

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

cars = ('chevrolet', 'ford', 'gmc')
cars.clear()
print(cars)  

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

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

cars = ('chevrolet', 'ford', 'gmc')
cars(1) = 'cadillac'
print(cars)  

روش به هم پیوستن دو لیست

شما می توانید دو یا چند لیست را با استفاده از + اپراتور:

cars = ('chevrolet', 'ford', 'gmc')
more_cars = ('cadillac', 'buick')
all_cars = cars + more_cars
print(all_cars)  

چگونه از یک لیست چندتایی بسازیم

شما می توانید یک لیست جدید ایجاد کنید که حاوی چندین نسخه از یک لیست موجود با استفاده از * اپراتور.

cars = ('chevrolet', 'ford', 'gmc')
lots_of_cars = cars * 3
print(lots_of_cars) 

متدهای رایج لیست در پایتون

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

این فهرست مطالب() روش

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

بیایید نگاهی به نحو استفاده از آن بیندازیم index() روش:

list_name.index(value, start, end)

جایی که:

• list_name نام لیستی است که می خواهید جستجو کنید
• value مقداری است که می خواهید در لیست پیدا کنید
• start ایندکس اختیاری است که از آن جستجو شروع می شود (پیش فرض به 0)
• end ایندکس اختیاری است که در آن جستجو پایان می یابد (به طور پیش فرض تا انتهای لیست)

بیایید ببینیم چگونه می توانیم از آن استفاده کنیم index() روش برای یافتن عناصر در تغییر یافته cars لیست، مشابه آنچه در بخش های قبلی استفاده کردیم:

cars = ('chevrolet', 'ford', 'gmc', 'ford')
print(cars.index('ford'))  
print(cars.index('ford', 2))  

در این مثال، ما لیستی از میوه ها را داریم و از آن استفاده می کنیم index() روشی برای یافتن شاخص اولین وقوع مقدار 'ford'. اولین تماس به index() برمی گرداند 1، که شاخص اولین وقوع است 'ford' در لیست تماس دوم به index() یک شاخص شروع را مشخص می کند 2، بنابراین شروع به جستجو می کند 'ford' از عنصر سوم لیست و برمی گردد 3، که شاخص دومین وقوع است 'ford'.

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

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

list_name.count(value)

اینجا list_name نام لیستی است که می خواهید جستجو کنید و value مقداری است که می خواهید در لیست بشمارید.

اکنون می‌توانیم به یک مثال ساده از روش استفاده از آن نگاهی بیندازیم count() روش:

cars = ('chevrolet', 'ford', 'gmc', 'ford')
print(cars.count('ford'))  

در این مثال، ما لیستی از خودروها را داریم و از آن استفاده می کنیم count() روش برای شمارش تعداد دفعات مقدار 'ford' در لیست ظاهر می شود. روش برمی گردد 2، که تعداد دفعات آن است 'ford' در لیست ظاهر می شود.

cars = ('chevrolet', 'FORD', 'gmc', 'ford')
print((c.lower() for c in cars).count('ford'))  

این معکوس() روش

این reverse() متد یک تابع داخلی در پایتون است که برای معکوس کردن ترتیب عناصر در یک لیست استفاده می شود. هیچ آرگومان نمی گیرد و لیست اصلی را در جای خود تغییر می دهد. در اینجا مثالی از روش استفاده از آن آورده شده است reverse() روش:

cars = ('chevrolet', 'ford', 'gmc')
cars.reverse()
print(cars)  

در اینجا، ما دوباره لیستی از خودروها را داریم و از آن استفاده می کنیم reverse() روشی برای معکوس کردن ترتیب عناصر در لیست. این روش لیست اصلی را در جای خود تغییر می دهد و ما print لیست اصلاح شده، که اکنون عناصر را به ترتیب معکوس دارد.

این مرتب سازی() روش

این sort() متد در پایتون عناصر یک لیست را مرتب می کند ترتیب صعودی به صورت پیش فرض. شما همچنین می توانید رفتار مرتب سازی را با استفاده از پارامترهای اختیاری مانند تغییر دهید key و reverse. این روش لیست را مرتب می کند درجا، به این معنی که لیست اصلی را اصلاح می کند و لیست مرتب شده جدیدی ایجاد نمی کند.

ابتدا، بیایید نگاهی به نحو آن بیاندازیم sort() روش در پایتون:

list.sort(key=None, reverse=False)

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

اکنون می‌توانیم به نمونه‌هایی از استفاده از آن نگاهی بیندازیم sort() روش مرتب سازی لیست ها در پایتون:

numbers = (4, 2, 9, 1, 7)
numbers.sort()
print(numbers)  


cars = ('chevrolet', 'ford', 'gmc')
cars.sort(reverse=True)
print(cars)  


tuples = ((1, 'one'), (3, 'three'), (2, 'two'), (4, 'four'))
tuples.sort(key=lambda x: x(1))
print(tuples)  

این کپی 🀄() روش

در پایتون، copy() روش برای ایجاد a استفاده می شود کپی کم عمق از یک لیست یک کپی کم عمق به process ایجاد یک شی مجموعه جدید (مانند فهرست، فرهنگ لغت یا مجموعه) که کپی شی اصلی است، با یک مرجع جدید، اما با عناصر مشابه شی اصلی:

cars = ('chevrolet', 'ford', 'gmc')


new_cars = cars.copy()


print(cars is new_cars)        


print(cars)       
print(new_cars)   


cars(2) = 'cadillac'


print(cars)       
print(new_cars)   

با این حال، خود عناصر کپی عمیق نیستند، بنابراین اگر شی اصلی شامل ساختارهای تودرتو (مانند لیست ها یا فرهنگ لغت ها) باشد، ارجاعات به این اشیاء تودرتو کپی می شوند، نه خود اشیا. این بدان معنی است که تغییرات ایجاد شده در اشیاء تودرتو در شی اصلی نیز در کپی کم عمق منعکس خواهد شد و بالعکس:`

cars = ('chevrolet', 'ford', ('gmc', 'chevrolet'))


new_cars = cars.copy()


print(cars is new_cars)        


print(cars)       
print(new_cars)   


cars(2)(1) = 'cadillac'


print(cars)       
print(new_cars)   

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

علاوه بر متدهای لیست داخلی، پایتون چندین توابع لیست را نیز ارائه می دهد که می توان از آنها برای انجام عملیات های مختلف استفاده کرد. روی لیست ها

این len () تابع

می توانید استفاده کنید len() تابعی برای تعیین طول لیست پایتون، که تعداد عناصر موجود در آن است. وقتی لیستی را به عنوان آرگومان به آن ارسال می کنید len() تابع، یک عدد صحیح نشان دهنده تعداد عناصر موجود در لیست را برمی گرداند:

my_list = (10, 20, 30, 40, 50)
length = len(my_list)
print(length)  

این my_list شامل 5 عنصر است، بنابراین len() تابع برمی گردد 5.

توجه به این نکته ضروری است که len() تابع ساختار لیست را در نظر می گیرد. به عنوان مثال، فرض کنید که یک لیست تودرتو دارید (یک لیست در یک لیست)، len() تابع فقط عناصر لیست بیرونی را می شمارد، نه عناصر تکی در لیست تودرتو:

nested_list = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
length = len(nested_list)
print(length)  

اینجا nested_list شامل 3 عنصر (که هر کدام یک لیست است)، بنابراین len() تابع برمی گردد 3.

دقیقه () و حداکثر () کارکرد

این min() و max() توابع توابع داخلی پایتون هستند که به ترتیب برای یافتن مقادیر حداقل و حداکثر از یک تکرار معین، مانند یک لیست، استفاده می‌شوند. این توابع کوچکترین و بزرگترین مقادیر را از تکرارپذیر برمیگردانند روی ترتیب طبیعی آنها (یعنی ترتیب عددی یا الفبایی).

بیایید نگاهی به یک مثال ساده از استفاده از min() و max() توابع با لیست اعداد صحیح پایتون:

my_list = (10, 20, 30, 40, 50)

minimum_value = min(my_list)
print(minimum_value)  

maximum_value = max(my_list)
print(maximum_value)  

این my_list شامل اعداد صحیح و min() و max() توابع به ترتیب کوچکترین و بزرگترین مقادیر را برمی گرداند.

شما همچنین می توانید استفاده کنید min() و max() توابع با لیست رشته ها در این حالت، توابع بر اساس کوچکترین و بزرگترین مقادیر را برمی گردانند روی به ترتیب حروف الفبا:

my_list = ('apple', 'banana', 'cherry', 'orange', 'grape')

minimum_value = min(my_list)
print(minimum_value)  

maximum_value = max(my_list)
print(maximum_value)  

این جمع () تابع

این sum() تابع مجموع تمام عناصر یک لیست را با فرض عددی بودن عناصر برمی گرداند. این sum() تابع تکرارپذیر را به عنوان آرگومان اول و آرگومان دوم اختیاری را می گیرد که مقدار شروع مجموع است (پیش فرض 0 است):

my_list = (10, 20, 30, 40, 50)
total = sum(my_list)
print(total)  

در این مثال، sum() تابع مجموع تمام اعداد صحیح را محاسبه می کند my_list و مقدار را برمی گرداند 150.

شما همچنین می توانید استفاده کنید sum() تابع با آرگومان دوم اختیاری برای تعیین مقدار شروع برای مجموع:

my_list = (10, 20, 30, 40, 50)
starting_value = 100
total = sum(my_list, starting_value)
print(total)  

در این مورد، جمع از شروع می شود 100 و سپس عناصر را اضافه می کند my_list، در مجموع از 250.

هر () و همه() کارکرد

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

any() برمی گرداند True اگر حداقل یک عنصر در تکرارپذیر درست باشد (به عنوان مثال، به True) و False در غیر این صورت:

my_list1 = (True, False, True, False)
my_list2 = (True, True, True)
my_list3 = (False, False, False)

result1 = any(my_list1)
print(result1)  

result2 = any(my_list2)
print(result2)  

result3 = any(my_list3)
print(result3)  

all() برمی گرداند True اگر همه عناصر در تکرارپذیر صادق باشند (یعنی ارزیابی به True) و False در غیر این صورت:

my_list1 = (True, False, True, False)
my_list2 = (True, True, True)
my_list3 = (False, False, False)

result1 = all(my_list1)
print(result1)  

result2 = all(my_list2)
print(result2)  

result3 = all(my_list3)
print(result3)  

شما همچنین می توانید استفاده کنید any() و all() توابع با درک لیست برای بررسی یک شرایط خاص روی عناصر یک لیست به عنوان مثال، می توانید بررسی کنید که آیا هر یک یا همه عناصر موجود در لیست اعداد صحیح زوج هستند:

numbers = (2, 4, 6, 8, 10)

any_even = any(num % 2 == 0 for num in numbers)
print(any_even)  

all_even = all(num % 2 == 0 for num in numbers)
print(all_even)  

از آنجایی که تمام عناصر موجود در numbers لیست زوج هستند، هر دو any() و all() برگشت True.

این مرتب شده () تابع

این sorted() تابع عناصر یک لیست را به ترتیب صعودی یا نزولی مرتب می کند. به طور پیش فرض، تابع a را برمی گرداند لیست جدید حاوی عناصر مرتب شده، بدون تغییر تکرار اصلی:

cars = ('chevrolet', 'ford', 'gmc', 'cadillac')
sorted_cars = sorted(cars)
print(sorted_cars)  

در این مثال، sorted() تابع یک لیست جدید حاوی عناصر مرتب شده از my_list به ترتیب صعودی

شما همچنین می توانید استفاده کنید sorted() عملکرد با اختیاری key آرگومان برای تعیین یک ترتیب مرتب سازی سفارشی بر اساس روی یک تابع:

cars = ('chevrolet', 'ford', 'gmc', 'cadillac')
sorted_cars = sorted(cars, key=len)
print(sorted_cars)  

در این مورد، sorted() تابع عناصر را مرتب می کند my_list مستقر روی آنها طول رشته.

علاوه بر این، sorted() تابع یک اختیاری می پذیرد reverse آرگومان، که می توان آن را تنظیم کرد True برای مرتب کردن عناصر به ترتیب نزولی:

cars = ('chevrolet', 'ford', 'gmc', 'cadillac')
sorted_cars = sorted(cars, reverse=True)
print(sorted_cars)  

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

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

درک لیست

درک لیست روشی مختصر و زیبا برای ایجاد یک لیست جدید از یک لیست موجود یا دیگر شیء قابل تکرار است. این به ویژه زمانی مفید است که می خواهید یک تبدیل یا فیلتر را برای عناصر یک لیست اعمال کنید.

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

numbers = (1, 2, 3, 4, 5)

squares = (num**2 for num in numbers)
print(squares)  

همچنین می توانید از عبارات شرطی در درک لیست برای فیلتر کردن عناصری که شرایط خاصی را ندارند استفاده کنید:

numbers = (1, 2, 3, 4, 5)

evens = (num for num in numbers if num % 2 == 0)
print(evens)  

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

توابع لامبدا هستند توابع ناشناس که می تواند به عنوان یک راه سریع برای انجام عملیات ساده استفاده شود روی لیست ها آنها به ویژه هنگامی مفید هستند که در ترکیب با روش های فهرست مانند استفاده شوند map()، filter()، و reduce():

numbers = (1, 2, 3, 4, 5)
squared_numbers = map(lambda x: x**2, numbers)
print(list(squared_numbers))  

همچنین می‌توانید از توابع لامبدا برای فیلتر کردن عناصری که شرایط خاصی را ندارند استفاده کنید filter() روش:

numbers = (1, 2, 3, 4, 5)

even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers))  

فهرست برش و گام برداشتن

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

numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
subset = numbers(2:7)
print(subset)  

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

numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
subset = numbers(-5:-2)
print(subset)  

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

numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
subset = numbers(1::2)
print(subset) 

تابع شمارش

این enumerate() تابع یک تابع داخلی پایتون است که به شما امکان می دهد از طریق یک لیست (یا سایر موارد تکرار شونده) تکرار کنید و در عین حال فهرست فعلی را پیگیری کنید. یک تکرار کننده را برمی گرداند که جفت فرم (شاخص، عنصر) را برای هر عنصر در لیست به دست می دهد.

cars = ('chevrolet', 'ford', 'gmc')
for index, car in enumerate(cars):
    print(index, car)

این به ما می دهد:

0 chevrolet
1 ford
2 gmc

عملکرد زیپ

این zip() تابع یک تابع داخلی پایتون است که دو یا چند لیست (یا تکرارپذیرهای دیگر) را به عنوان آرگومان می گیرد و یک تکرار کننده را برمی گرداند که تاپل هایی حاوی عناصر مربوطه را از هر لیست ورودی به دست می دهد. می توان از آن برای ترکیب عناصر از چندین لیست به صورت دوتایی استفاده کرد. مثلا:

names = ('Alice', 'Bob', 'Charlie')
ages = (25, 30, 35)
for name, age in zip(names, ages):
    print(name, age)

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

Unpacking در پایتون به عملیاتی اشاره دارد که شامل تخصیص آیتم های تکرارپذیر به متغیرهای مختلف است:

numbers = (1, 2, 3)
a, b, c = numbers
print(a)  
print(b)  
print(c)  

مقادیر موجود در لیست numbers در متغیرها باز می شوند a، b، و c به ترتیب.

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

numbers = (1, 2, 3, 4, 5, 6)
a, b, *rest = numbers
print(a)  
print(b)  
print(rest)  

در این مورد، a و b به ترتیب عناصر اول و دوم را خواهد گرفت و rest یک لیست جدید حاوی عناصر باقی مانده خواهد بود.

شما همچنین می توانید استفاده کنید * عملگر برای گرفتن عناصر از وسط یک لیست:

numbers = (1, 2, 3, 4, 5, 6)
a, *middle, z = numbers
print(a)  
print(middle)  
print(z)  

a اولین عنصر خواهد بود، z آخرین عنصر خواهد بود و middle یک لیست جدید حاوی عناصر بین خواهد بود a و z.

نتیجه

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