Python list comprehensions අංකනය භාවිතා කිරීම

ව්යාපාරික

Python හි, නව ලැයිස්තුවක් උත්පාදනය කිරීමේදී ලැයිස්තු අවබෝධතා අංකනය භාවිතා කිරීම සරල ය.(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 මගින් කොන්දේසි සහිත අතු බෙදීම සමඟ අවබෝධතා අංකනය ලැයිස්තුගත කරන්න

if සමඟ කොන්දේසි සහිත අතු බෙදීම ද හැකි ය. postfix එකේ 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]

එම ක්‍රියාවලියම පෙරහන () සමඟ සිදු කළ හැක, නමුත් ලැයිස්තු අවබෝධතා අංකනය එහි සරල බව සහ පැහැදිලි බව සඳහා වඩාත් කැමති වේ.

ත්‍රිත්ව ක්‍රියාකරුවන් සමඟ සංයෝජනය (වෙනත් ආකාරයේ සැකසුම් නම්)

ඉහත උදාහරණයේ දී, නිර්ණායක සපුරාලන මූලද්‍රව්‍ය පමණක් සකසනු ලබන අතර, නිර්ණායක සපුරාලන්නේ නැති ඒවා නව ලැයිස්තුවෙන් බැහැර කරනු ලැබේ.

ඔබට තත්වය අනුව ක්‍රියාවලිය මාරු කිරීමට අවශ්‍ය නම්, හෝ ඔබට වෙනත් ආකාරයකින් කොන්දේසි තෘප්තිමත් නොවන මූලද්‍රව්‍ය වෙනස් ලෙස සැකසීමට අවශ්‍ය නම්, ත්‍රිත්ව ක්‍රියාකරු භාවිතා කරන්න.

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() සහ ගණන් කිරීම () සමඟ සංයෝජනය

ප්‍රකාශය සඳහා බොහෝ විට භාවිතා වන ප්‍රයෝජනවත් ශ්‍රිත අතර, බහු පුනරාවර්තන ඒකාබද්ධ කරන zip(), සහ එහි දර්ශකය සමඟ අගයක් ලබා දෙන ගණන් කිරීම () ඇතුළත් වේ.

ඇත්ත වශයෙන්ම, ලැයිස්තු අවබෝධතා අංකනය සමඟ 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')]

ගණන් කිරීමේ උදාහරණය().

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')]

if භාවිතා කරන විට අදහස පෙර පරිදිම වේ.

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)

ලැයිස්තු අවබෝධතා අංකනයෙහි ඇති වර්ග වරහන් [] curly brackets වෙත {} වෙනස් කිරීමෙන් කට්ටලයක් (set-type object) නිර්මාණය වේ.

{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}

යතුරු සහ අගයන් ලැයිස්තුවකින් නව ශබ්දකෝෂයක් සෑදීමට, zip() ශ්‍රිතය භාවිතා කරන්න.

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

Generator ප්‍රකාශන මඟින් if මෙන්ම ලැයිස්තුගත අවබෝධතා අංකනය භාවිතා කරමින් කොන්දේසි සහිත අතු සහ කැදැල්ලට ඉඩ සලසයි.

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 අවබෝධතා අංකනයක් නොමැත, නමුත් ඔබ tuple() හි තර්කයක් ලෙස generator ප්‍රකාශනයක් භාවිතා කරන්නේ නම්, ඔබට අවබෝධතා අංකනය තුළ 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