بتل کد Battle Codeدارد باز می‌شود…

آموزش پایتون

list comprehension در پایتون: از حلقه for تا یک خط کد

۹ دقیقه مطالعه · ۳۰ مهر ۱۴۰۵

فهرست مطالب
  1. از حلقه‌ی for تا list comprehension
  2. تبدیل همه‌ی عضوها
  3. فیلتر کردن با if
  4. if/else داخل list comprehension
  5. comprehension تو در تو
  6. dictionary comprehension و set comprehension
  7. کی از list comprehension استفاده نکنیم؟
  8. سؤال‌های پرتکرار

list comprehension در پایتون روشی کوتاه برای ساختن یک لیست تازه از روی یک لیست یا هر چیز قابل پیمایش دیگر، در یک خط است. شکل کلی‌اش [expression for item in iterable] است؛ مثلاً [n * n for n in range(5)] لیست [0, 1, 4, 9, 16] را می‌سازد. می‌شود یک if هم به آخرش اضافه کرد تا فقط بعضی عضوها انتخاب شوند. هر list comprehension را می‌شود با یک حلقه‌ی for و append هم نوشت؛ فقط کوتاه‌تر و معمولاً خواناتر است.

در این مقاله از یک حلقه‌ی معمولی شروع می‌کنیم و قدم‌به‌قدم به list comprehension می‌رسیم. بعد فیلتر کردن با if، انتخاب بین دو مقدار با if/else، comprehension تو در تو و برادرهایش یعنی dictionary comprehension و set comprehension را می‌بینیم. آخر هم می‌گوییم کی بهتر است سراغ این روش نروید. پیش‌نیاز این مقاله آشنایی با لیست در پایتون و حلقه for است. همه‌ی مثال‌ها را می‌توانید در ویرایشگر آنلاین پایتون اجرا کنید و تغییرشان دهید.

از حلقه‌ی for تا list comprehension

فرض کنید لیستی از مربع عددهای ۱ تا ۵ می‌خواهید. با چیزهایی که تا الان بلدید، احتمالاً این‌طور می‌نویسید:

squares = []
for n in range(1, 6):
    squares.append(n * n)
print(squares)
[1, 4, 9, 16, 25]

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

squares = [n * n for n in range(1, 6)]
print(squares)
[1, 4, 9, 16, 25]

نتیجه دقیقاً یکی است. برای خواندن list comprehension، آن را مثل یک جمله بخوانید: «لیستی از n * n برای هر n در range(1, 6)». هر list comprehension سه بخش دارد:

بخشدر مثال بالامعنی
عبارت (expression)n * nبا هر عضو چه کنیم؛ نتیجه‌اش در لیست تازه می‌رود
متغیر حلقهnاسمی برای عضوی که الان نوبت آن است
منبع (iterable)range(1, 6)عضوها از کجا می‌آیند: لیست، رشته، بازه و…

اگر دو نسخه‌ی بالا را کنار هم بگذارید، می‌بینید که list comprehension همان حلقه است که عبارت append آن به اول خط آمده و لیست خالی و append حذف شده‌اند.

تبدیل همه‌ی عضوها

ساده‌ترین کاربرد list comprehension این است که روی همه‌ی عضوهای یک لیست یک کار مشخص انجام دهیم و نتیجه‌ها را در لیست تازه‌ای جمع کنیم. لیست اصلی دست‌نخورده می‌ماند:

names = ["sara", "ali", "mina"]
print([name.upper() for name in names])
print([len(name) for name in names])
print([name[0] for name in names])
['SARA', 'ALI', 'MINA']
[4, 3, 4]
['s', 'a', 'm']

یک کاربرد خیلی رایج، تبدیل متن به عدد است. وقتی کاربر چند عدد را با فاصله تایپ می‌کند، split() آن‌ها را به لیستی از متن‌ها تبدیل می‌کند و list comprehension همه را به عدد:

line = "4 8 15 16 23 42"
numbers = [int(x) for x in line.split()]
print(numbers)
print(sum(numbers))
[4, 8, 15, 16, 23, 42]
108

در برنامه‌ی واقعی، line از input() می‌آید. یک مثال دیگر، تبدیل دمای سلسیوس به فارنهایت است:

celsius = [0, 10, 25, 100]
fahrenheit = [c * 9 / 5 + 32 for c in celsius]
print(fahrenheit)
[32.0, 50.0, 77.0, 212.0]

منبع comprehension لازم نیست لیست باشد. هر چیزی که بشود با for رویش حرکت کرد، مثل رشته یا range، کار می‌کند: [ch for ch in "abc"] لیست ['a', 'b', 'c'] را می‌سازد.

فیلتر کردن با if

اگر بعد از بخش for یک if بنویسید، فقط عضوهایی که شرط برایشان درست است وارد لیست تازه می‌شوند. این همان الگوی «لیست خالی، حلقه، شرط، append» است که در یک خط نوشته شده:

nums = [3, 8, 1, 10, 6, 7]
evens = [n for n in nums if n % 2 == 0]
print(evens)
big = [n for n in nums if n > 5]
print(big)
[8, 10, 6]
[8, 10, 6, 7]

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

words = ["apple", "banana", "avocado", "cherry", "apricot"]
a_words = [w for w in words if w.startswith("a")]
print(a_words)
long_words = [w.upper() for w in words if len(w) > 5]
print(long_words)
['apple', 'avocado', 'apricot']
['BANANA', 'AVOCADO', 'CHERRY', 'APRICOT']

ترتیب اجرا را این‌طور تصور کنید: اول for یک عضو برمی‌دارد، بعد if بررسی می‌کند که آن را نگه دارد یا نه، و اگر نگه داشت، عبارت اول خط رویش اجرا می‌شود.

مثال واقعی: نمره‌های کلاس

معلمی می‌خواهد به همه‌ی نمره‌ها ۲ نمره اضافه کند، اما هیچ نمره‌ای از ۲۰ بیشتر نشود، و بعد بداند چند نفر قبول شده‌اند. با دو comprehension کوتاه این کار تمام است:

scores = [12, 19, 6, 17, 20]
curved = [min(s + 2, 20) for s in scores]
print(curved)
passed = [s for s in curved if s >= 10]
print(f"{len(passed)} of {len(scores)} passed")
[14, 20, 8, 19, 20]
4 of 5 passed

min(s + 2, 20) بین نمره‌ی جدید و ۲۰ کوچک‌تر را برمی‌دارد؛ پس ۱۹ به ۲۰ می‌رسد، نه ۲۱. comprehension اول همه‌ی نمره‌ها را تبدیل کرد و دومی فقط نمره‌های قبولی را نگه داشت. لیست اصلی scores هم دست‌نخورده باقی ماند و اگر بعداً لازمش داشته باشیم، هنوز در دسترس است.

if/else داخل list comprehension

گاهی نمی‌خواهید عضوی را حذف کنید؛ می‌خواهید برای هر عضو بین دو مقدار یکی را انتخاب کنید. در این حالت از عبارت شرطی A if condition else B استفاده می‌کنیم و جایش قبل از for است، نه بعد از آن:

nums = [3, 8, 1, 10, 6]
labels = ["even" if n % 2 == 0 else "odd" for n in nums]
print(labels)
scores = [12, 19, 8, 17]
results = ["pass" if s >= 10 else "fail" for s in scores]
print(results)
['odd', 'even', 'odd', 'even', 'even']
['pass', 'pass', 'fail', 'pass']

جای if در این دو حالت، رایج‌ترین منبع اشتباه است. اگر else را بعد از for بنویسید، پایتون خطای نحوی می‌دهد:

nums = [3, 8, 1, 10, 6]
big = [n for n in nums if n > 5 else 0]

خط آخر پیام خطا:

SyntaxError: invalid syntax

این جدول قانون را خلاصه می‌کند:

کارجای شرطنمونهلیست تازه چند عضو دارد؟
فیلتر کردنبعد از for، فقط if[n for n in nums if n > 5]ممکن است کمتر از لیست اصلی
انتخاب بین دو مقدارقبل از for، با if و else[n if n > 5 else 0 for n in nums]همیشه برابر لیست اصلی

یک راه ساده برای به خاطر سپردن: if تنها «دربان» است و تصمیم می‌گیرد چه کسی وارد شود، پس دم در یعنی آخر خط می‌ایستد. if/else «لباس» عضوها را عوض می‌کند، پس کنار عبارت اول خط می‌آید.

comprehension تو در تو

یک list comprehension می‌تواند بیشتر از یک for داشته باشد. ترتیب forها همان ترتیب حلقه‌های تو در توی معمولی است: اولی حلقه‌ی بیرونی و دومی حلقه‌ی درونی:

pairs = [(x, y) for x in [1, 2] for y in ["a", "b"]]
print(pairs)
[(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')]

این کد دقیقاً معادل دو حلقه‌ی for تو در تو است که در حلقه‌ی درونی، (x, y) به لیست اضافه می‌شود. هر عضو نتیجه یک تاپل است؛ درباره‌ی تاپل، مقاله‌ی تاپل و مجموعه در پایتون را ببینید.

صاف کردن لیست تو در تو

یکی از کاربردهای دو for، تبدیل یک لیست تو در تو به یک لیست ساده است:

grid = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [n for row in grid for n in row]
print(flat)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

ساختن جدول با comprehension درون comprehension

اگر عبارت اول خط خودش یک list comprehension باشد، نتیجه یک لیست تو در تو است. این مثال جدول ضرب ۳ در ۳ را می‌سازد:

table = [[r * c for c in range(1, 4)] for r in range(1, 4)]
for row in table:
    print(row)
[1, 2, 3]
[2, 4, 6]
[3, 6, 9]

همین شکل، راه درست ساختن یک صفحه‌ی خالی برای بازی است: [[0] * 3 for _ in range(3)]. زیرخط _ اسم رایجی برای متغیر حلقه‌ای است که از مقدارش استفاده نمی‌کنیم. برخلاف [[0] * 3] * 3، این روش برای هر ردیف یک لیست جداگانه می‌سازد. چرا این فرق مهم است؟ در مقاله‌ی لیست در پایتون، بخش «دام ساختن جدول با ضرب» را ببینید.

dictionary comprehension و set comprehension

همین ایده با آکولاد هم کار می‌کند. اگر داخل آکولاد key: value بنویسید، یک دیکشنری ساخته می‌شود و اگر فقط یک عبارت بنویسید، یک مجموعه (set):

names = ["sara", "ali", "mina"]
lengths = {name: len(name) for name in names}
print(lengths)
squares = {n: n * n for n in range(1, 5)}
print(squares)
{'sara': 4, 'ali': 3, 'mina': 4}
{1: 1, 2: 4, 3: 9, 4: 16}

با items() می‌شود روی یک دیکشنری موجود حرکت کرد و فقط بعضی کلیدها را نگه داشت. این مثال فقط دانش‌آموزهایی را نگه می‌دارد که نمره‌شان ۱۲ یا بیشتر است:

scores = {"sara": 18, "ali": 11, "mina": 15}
passed = {name: s for name, s in scores.items() if s >= 12}
print(passed)
{'sara': 18, 'mina': 15}

set comprehension مثل list comprehension است، اما چون مجموعه عضو تکراری نگه نمی‌دارد، تکراری‌ها خودبه‌خود حذف می‌شوند:

words = ["cat", "dog", "bird", "fish", "cow"]
lengths = {len(w) for w in words}
print(lengths)
{3, 4}

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

پرانتز تاپل نمی‌سازد

شاید فکر کنید با پرانتز هم «tuple comprehension» ساخته می‌شود، اما این‌طور نیست. پرانتز یک generator expression می‌سازد؛ چیزی که عضوها را یکی‌یکی و فقط وقتی لازم شد تولید می‌کند. اگر تاپل می‌خواهید، آن را به tuple() بدهید. generator برای وقتی عالی است که فقط جمع یا بیشینه را لازم دارید و نگه داشتن کل لیست ضرورتی ندارد:

total = sum(n * n for n in range(1, 6))
print(total)
print(tuple(n * 2 for n in range(4)))
55
(0, 2, 4, 6)

کی از list comprehension استفاده نکنیم؟

list comprehension ابزار خوبی است، اما قرار نیست جای همه‌ی حلقه‌ها را بگیرد. هدف کد خوانا است، نه کد کوتاه. در این حالت‌ها حلقه‌ی معمولی بهتر است:

  • وقتی خیلی شلوغ می‌شود. اگر comprehension دو for و چند شرط دارد و برای فهمیدنش باید دو بار بخوانید، آن را به حلقه تبدیل کنید.
  • وقتی لیست نمی‌خواهید. comprehension برای ساختن لیست است. اگر فقط می‌خواهید چیزی چاپ کنید یا کاری انجام دهید، حلقه‌ی ساده بنویسید.
  • وقتی به break یا چند دستور نیاز دارید. comprehension نمی‌تواند وسط کار متوقف شود و برای هر عضو فقط یک عبارت دارد.
  • وقتی داده خیلی بزرگ است و فقط یک جواب می‌خواهید. برای جمع یا شمردن، generator expression حافظه‌ی کمتری مصرف می‌کند.

این مثال نشان می‌دهد چرا comprehension برای چاپ کردن مناسب نیست:

result = [print(n) for n in [1, 2, 3]]
print(result)
1
2
3
[None, None, None]

عددها چاپ شدند، اما یک لیست بی‌مصرف از None هم ساخته شد، چون print چیزی برنمی‌گرداند. همین کار با یک حلقه‌ی دوخطی ساده‌تر و درست‌تر است. یک comprehension شلوغ را هم ببینید:

grid = [[1, -2, 3], [-4, 5, -6]]
result = [n * 10 if n > 0 else 0 for row in grid for n in row if n != 3]
print(result)
[10, 0, 0, 50, 0]

این کد درست کار می‌کند، اما فهمیدن این‌که دقیقاً چه می‌کند وقت می‌گیرد. همین منطق با دو حلقه‌ی تو در تو و چند if چند خط بیشتر می‌شود، اما هر کسی آن را در یک نگاه می‌فهمد.

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

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

سؤال‌های پرتکرار

list comprehension در پایتون چیست؟

روشی کوتاه برای ساختن یک لیست تازه از روی یک لیست یا هر چیز قابل پیمایش دیگر است. شکل کلی‌اش [expression for item in iterable] است و می‌شود یک if هم برای فیلتر کردن به آخرش اضافه کرد. هر list comprehension معادل یک حلقه‌ی for با append است.

آیا list comprehension از حلقه‌ی for سریع‌تر است؟

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

چطور در list comprehension از if و else استفاده کنم؟

اگر فقط می‌خواهید فیلتر کنید، if را بعد از for بنویسید: [n for n in nums if n > 0]. اگر برای هر عضو بین دو مقدار انتخاب می‌کنید، if/else را قبل از for بنویسید: [n if n > 0 else 0 for n in nums].

آیا tuple comprehension در پایتون وجود دارد؟

نه. پرانتز یک generator expression می‌سازد، نه تاپل. اگر تاپل می‌خواهید، generator را به tuple() بدهید: tuple(n * 2 for n in nums).

dictionary comprehension چه فرقی با list comprehension دارد؟

dictionary comprehension با آکولاد نوشته می‌شود و برای هر عضو یک جفت key: value می‌سازد، مثل {name: len(name) for name in names}. نتیجه‌اش یک دیکشنری است، نه لیست.

کی بهتر است از list comprehension استفاده نکنم؟

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

همین حالا روی Battle Code تمرین کن

مقاله‌های دیگر

همه‌ی مقاله‌ها