ازگر کی فہرست کو سمجھنے کے اشارے کا استعمال کرنا

کاروبار

ازگر میں، نئی فہرست تیار کرتے وقت فہرست کی تفہیم کے اشارے کا استعمال کرنا آسان ہے۔(List comprehensions)

اس مضمون میں، ہم سب سے پہلے مندرجہ ذیل بات کریں گے۔

  • بنیادی قسم کی فہرست فہم اشارے
  • مشروط برانچنگ کے ساتھ فہم اشارے کی فہرست بذریعہ if
  • ٹرنری آپریٹرز کے ساتھ مجموعہ (اگر دوسری طرح کی پروسیسنگ)
  • zip(),enumerate()ان کے ساتھ مجموعہ
  • نیسٹڈ لسٹ انکلوژن نوٹیشن

اگلا، ہم نمونہ کوڈ کے ساتھ فہرست فہمی اشارے کے سیٹ کی وضاحت کریں گے۔

  • شامل کرنے کا اشارہ مقرر کریں۔(Set comprehensions)
  • لغت کی شمولیت کا اشارہ(Dict comprehensions)
  • جنریٹر کی قسم(Generator expressions)

بنیادی قسم کی فہرست فہم اشارے

فہرست فہمی اشارے مندرجہ ذیل لکھا گیا ہے۔

[Expression for Any Variable Name in Iterable Object]

یہ ایک قابل تکرار آبجیکٹ کے ہر عنصر کو لیتا ہے جیسے کہ فہرست، ٹیپل، یا رینج کسی صوابدیدی متغیر نام سے اور اسے اظہار کے ساتھ جانچتا ہے۔ ایک عنصر کے طور پر تشخیص کے نتیجے کے ساتھ ایک نئی فہرست واپس آ گئی ہے۔

بیان کے برابر کے ساتھ ایک مثال دی گئی ہے۔

squares = [i**2 for i in range(5)]
print(squares)
# [0, 1, 4, 9, 16]

squares = []
for i in range(5):
    squares.append(i**2)

print(squares)
# [0, 1, 4, 9, 16]

یہی عمل map() کے ساتھ بھی کیا جا سکتا ہے، لیکن فہرست فہمی اشارے کو اس کی سادگی اور وضاحت کے لیے ترجیح دی جاتی ہے۔

مشروط برانچنگ کے ساتھ فہم اشارے کی فہرست بذریعہ if

اگر ممکن ہو تو مشروط برانچنگ بھی۔ اگر پوسٹ فکس میں درج ذیل لکھیں۔

[Expression for Any Variable Name in Iterable Object if Conditional Expression]

صرف تکراری آبجیکٹ کے عناصر جن کا مشروط اظہار درست ہے اظہار کے ذریعہ جانچا جاتا ہے، اور ایک نئی فہرست جس کے عناصر نتیجہ ہیں واپس کر دی جاتی ہے۔

آپ مشروط اظہار میں کوئی بھی متغیر نام استعمال کر سکتے ہیں۔

بیان کے برابر کے ساتھ ایک مثال دی گئی ہے۔

odds = [i for i in range(10) if i % 2 == 1]
print(odds)
# [1, 3, 5, 7, 9]

odds = []
for i in range(10):
    if i % 2 == 1:
        odds.append(i)

print(odds)
# [1, 3, 5, 7, 9]

اسی عمل کو filter() کے ساتھ بھی کیا جا سکتا ہے، لیکن فہرست فہمی اشارے کو اس کی سادگی اور وضاحت کے لیے ترجیح دی جاتی ہے۔

ٹرنری آپریٹرز کے ساتھ مجموعہ (اگر دوسری طرح کی پروسیسنگ)

اوپر دی گئی مثال میں، صرف ان عناصر پر کارروائی کی جاتی ہے جو معیار پر پورا اترتے ہیں، اور جو لوگ معیار پر پورا نہیں اترتے ہیں انہیں نئی ​​فہرست سے خارج کر دیا جاتا ہے۔

اگر آپ حالت کے لحاظ سے عمل کو تبدیل کرنا چاہتے ہیں، یا اگر آپ ایسے عناصر پر کارروائی کرنا چاہتے ہیں جو شرط کو مختلف طریقے سے مطمئن نہیں کرتے ہیں، جیسا کہ دوسری صورت میں، ٹرنری آپریٹر کا استعمال کریں۔

Python میں، ٹرنری آپریٹر کو اس طرح لکھا جا سکتا ہے۔

Value When True if Conditional Expression else Value When False

یہ فہرست فہمی اشارے کے اظہار کے حصے میں استعمال ہوتا ہے جیسا کہ ذیل میں دکھایا گیا ہے۔

[Value When True if Conditional Expression else Value When False for Any Variable Name in Iterable Object]

بیان کے برابر کے ساتھ ایک مثال دی گئی ہے۔

odd_even = ['odd' if i % 2 == 1 else 'even' for i in range(10)]
print(odd_even)
# ['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']

odd_even = []
for i in range(10):
    if i % 2 == 1:
        odd_even.append('odd')
    else:
        odd_even.append('even')

print(odd_even)
# ['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']

صحیح اور غلط اقدار کے لیے صوابدیدی متغیر ناموں کا استعمال کرتے ہوئے تاثرات لکھنا بھی ممکن ہے۔

اگر شرط مطمئن ہو جائے تو، کچھ پروسیسنگ کی جاتی ہے، بصورت دیگر اصل تکراری چیز کی قدر میں کوئی تبدیلی نہیں کی جاتی ہے۔

odd10 = [i * 10 if i % 2 == 1 else i for i in range(10)]
print(odd10)
# [0, 10, 2, 30, 4, 50, 6, 70, 8, 90]

zip() اور enumerate() کے ساتھ مجموعہ

مفید فنکشنز جو اکثر اسٹیٹمنٹ کے لیے استعمال ہوتے ہیں ان میں zip() شامل ہیں، جو ایک سے زیادہ اٹیریبلز کو جوڑتا ہے، اور enumerate()، جو اس کے انڈیکس کے ساتھ ایک قدر واپس کرتا ہے۔

بلاشبہ، zip() اور enumerate() کو فہرست فہمی اشارے کے ساتھ استعمال کرنا ممکن ہے۔ یہ کوئی خاص نحو نہیں ہے، اور اگر آپ بیان کے ساتھ خط و کتابت پر غور کریں تو یہ مشکل نہیں ہے۔

zip() کی مثال۔

l_str1 = ['a', 'b', 'c']
l_str2 = ['x', 'y', 'z']

l_zip = [(s1, s2) for s1, s2 in zip(l_str1, l_str2)]
print(l_zip)
# [('a', 'x'), ('b', 'y'), ('c', 'z')]

l_zip = []
for s1, s2 in zip(l_str1, l_str2):
    l_zip.append((s1, s2))

print(l_zip)
# [('a', 'x'), ('b', 'y'), ('c', 'z')]

enumerate() کی مثال۔

l_enu = [(i, s) for i, s in enumerate(l_str1)]
print(l_enu)
# [(0, 'a'), (1, 'b'), (2, 'c')]

l_enu = []
for i, s in enumerate(l_str1):
    l_enu.append((i, s))

print(l_enu)
# [(0, 'a'), (1, 'b'), (2, 'c')]

اگر استعمال کرتے وقت آئیڈیا پہلے جیسا ہی ہے۔

l_zip_if = [(s1, s2) for s1, s2 in zip(l_str1, l_str2) if s1 != 'b']
print(l_zip_if)
# [('a', 'x'), ('c', 'z')]

ہر عنصر کو نئے عنصر کا حساب لگانے کے لیے بھی استعمال کیا جا سکتا ہے۔

l_int1 = [1, 2, 3]
l_int2 = [10, 20, 30]

l_sub = [i2 - i1 for i1, i2 in zip(l_int1, l_int2)]
print(l_sub)
# [9, 18, 27]

نیسٹڈ لسٹ انکلوژن نوٹیشن

لوپس کے لیے نیسٹنگ کی طرح، فہرست فہمی اشارے کو بھی نیسٹ کیا جا سکتا ہے۔

[Expression for Variable Name 1 in Iterable Object 1
    for Variable Name 2 in Iterable Object 2
        for Variable Name 3 in Iterable Object 3 ... ]

سہولت کے لیے، لائن بریک اور انڈینٹیشن شامل کیے گئے ہیں، لیکن گرامر کے لیے ان کی ضرورت نہیں ہے۔ انہیں ایک ہی لائن پر جاری رکھا جا سکتا ہے۔

بیان کے برابر کے ساتھ ایک مثال دی گئی ہے۔

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

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

flat = []
for row in matrix:
    for x in row:
        flat.append(x)

print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

متعدد متغیرات کا استعمال بھی ممکن ہے۔

cells = [(row, col) for row in range(3) for col in range(2)]
print(cells)
# [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1)]

آپ مشروط برانچنگ بھی کر سکتے ہیں۔

cells = [(row, col) for row in range(3)
         for col in range(2) if col == row]
print(cells)
# [(0, 0), (1, 1)]

ہر قابل تکرار آبجیکٹ کے لیے مشروط طور پر برانچ کرنا بھی ممکن ہے۔

cells = [(row, col) for row in range(3) if row % 2 == 0
         for col in range(2) if col % 2 == 0]
print(cells)
# [(0, 0), (2, 0)]

شامل کرنے کا اشارہ مقرر کریں۔(Set comprehensions)

اسکوائر بریکٹ [] کو فہرست فہمی اشارے میں گھوبگھرالی بریکٹ {} میں تبدیل کرنے سے ایک سیٹ (سیٹ ٹائپ آبجیکٹ) بنتا ہے۔

{Expression for Any Variable Name in Iterable Object}

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

لغت کی شمولیت کا اشارہ(Dict comprehensions)

لغت (ڈکٹ ٹائپ آبجیکٹ) بھی فہم اشارے کے ساتھ تیار کی جاسکتی ہیں۔

{}، اور اظہار کے حصے میں کلید اور قدر کو بطور کلید: قدر کی وضاحت کریں۔

{Key: Value for Any Variable Name in Iterable Object}

کلید اور قدر کے لیے کسی بھی اظہار کی وضاحت کی جا سکتی ہے۔

l = ['Alice', 'Bob', 'Charlie']

d = {s: len(s) for s in l}
print(d)
# {'Alice': 5, 'Bob': 3, 'Charlie': 7}

کلیدوں اور اقدار کی فہرست سے ایک نئی لغت بنانے کے لیے، زپ() فنکشن استعمال کریں۔

keys = ['k1', 'k2', 'k3']
values = [1, 2, 3]

d = {k: v for k, v in zip(keys, values)}
print(d)
# {'k1': 1, 'k2': 2, 'k3': 3}

جنریٹر کی قسم(Generator expressions)

اگر فہرست کی تفہیم کے اشارے میں مربع بریکٹ [] کو گول بریکٹ () کے طور پر استعمال کیا جاتا ہے تو ٹیپل کے بجائے ایک جنریٹر واپس کیا جاتا ہے۔ اسے جنریٹر اظہار کہتے ہیں۔

فہرست فہم اشارے کی مثال۔

l = [i**2 for i in range(5)]

print(l)
# [0, 1, 4, 9, 16]

print(type(l))
# <class 'list'>

جنریٹر کے اظہار کی مثال۔ اگر آپ پرنٹ () جنریٹر جیسا ہے تو، یہ اس کے مواد کو پرنٹ نہیں کرے گا، لیکن اگر آپ اسے بیان کے لیے چلاتے ہیں، تو آپ مواد حاصل کر سکتے ہیں۔

g = (i**2 for i in range(5))

print(g)
# <generator object <genexpr> at 0x10af944f8>

print(type(g))
# <class 'generator'>

for i in g:
    print(i)
# 0
# 1
# 4
# 9
# 16

جنریٹر ایکسپریشنز مشروط برانچنگ اور نیسٹنگ کی اجازت دیتے ہیں اگر کے ساتھ ساتھ فہرست فہم اشارے کا استعمال کرتے ہوئے.

g_cells = ((row, col) for row in range(0, 3)
           for col in range(0, 2) if col == row)

print(type(g_cells))
# <class 'generator'>

for i in g_cells:
    print(i)
# (0, 0)
# (1, 1)

مثال کے طور پر، اگر فہرست فہمی اشارے کا استعمال کرتے ہوئے عناصر کی ایک بڑی تعداد کے ساتھ ایک فہرست تیار کی جاتی ہے اور پھر بیان کے لیے کے ساتھ لوپ کی جاتی ہے، اگر فہرست فہمی اشارے کا استعمال کیا جائے تو تمام عناصر پر مشتمل فہرست شروع میں تیار کی جائے گی۔ دوسری طرف، اگر آپ جنریٹر ایکسپریشن استعمال کرتے ہیں، تو ہر بار جب لوپ دہرایا جاتا ہے، عناصر ایک ایک کرکے پیدا ہوتے ہیں، اس طرح استعمال شدہ میموری کی مقدار کم ہوجاتی ہے۔

اگر جنریٹر کا اظہار فنکشن کی واحد دلیل ہے تو گول بریکٹ () کو چھوڑا جا سکتا ہے۔

print(sum([i**2 for i in range(5)]))
# 30

print(sum((i**2 for i in range(5))))
# 30

print(sum(i**2 for i in range(5)))
# 30

جہاں تک پروسیسنگ کی رفتار کا تعلق ہے، جب تمام عناصر پر کارروائی کی جاتی ہے تو فہرست کی سمجھ بوجھ اکثر جنریٹر اشارے سے تیز ہوتی ہے۔

تاہم، جب تمام() یا کسی بھی() کے ساتھ فیصلہ کرتے ہیں، مثال کے طور پر، غلط یا درست ہونے پر نتیجہ کا تعین کیا جاتا ہے، اس لیے جنریٹر کے اظہارات کا استعمال فہرست کی تفہیم کے اشارے کے استعمال سے تیز تر ہو سکتا ہے۔

کوئی ٹیپل کمپری ہینشن نوٹیشن نہیں ہے، لیکن اگر آپ جنریٹر ایکسپریشن کو tuple() کی دلیل کے طور پر استعمال کرتے ہیں، تو آپ فہمی اشارے میں ایک ٹیپل تیار کر سکتے ہیں۔

t = tuple(i**2 for i in range(5))

print(t)
# (0, 1, 4, 9, 16)

print(type(t))
# <class 'tuple'>
Copied title and URL