பைதான் பட்டியல் புரிதல் குறியீட்டைப் பயன்படுத்துதல்

வணிக

பைத்தானில், புதிய பட்டியலை உருவாக்கும் போது பட்டியல் புரிதல் குறியீட்டைப் பயன்படுத்துவது எளிது.(List comprehensions)

இந்த கட்டுரையில், முதலில் பின்வருவனவற்றைப் பற்றி விவாதிப்போம்

  • பட்டியல் புரிதல் குறிப்பின் அடிப்படை வகை
  • என்றால் மூலம் நிபந்தனைக்குட்பட்ட கிளைகளுடன் புரிதல் குறியீட்டை பட்டியலிடுங்கள்
  • மும்முனை ஆபரேட்டர்களுடன் இணைந்து (வேறு போன்ற செயலாக்கம் இருந்தால்)
  • 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]

அதே செயல்முறையை வரைபடம்() மூலம் செய்ய முடியும், ஆனால் பட்டியலைப் புரிந்துகொள்ளும் குறியீடு அதன் எளிமை மற்றும் தெளிவுக்காக விரும்பப்படுகிறது.

என்றால் மூலம் நிபந்தனைக்குட்பட்ட கிளைகளுடன் புரிதல் குறியீட்டை பட்டியலிடுங்கள்

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]

அதே செயல்முறையை வடிகட்டி() மூலம் செய்ய முடியும், ஆனால் பட்டியல் புரிதல் குறியீடு அதன் எளிமை மற்றும் தெளிவுக்காக விரும்பப்படுகிறது.

மும்முனை ஆபரேட்டர்களுடன் இணைந்து (வேறு போன்ற செயலாக்கம் இருந்தால்)

மேலே உள்ள எடுத்துக்காட்டில், நிபந்தனைகளை பூர்த்தி செய்யும் கூறுகள் மட்டுமே செயலாக்கப்படும், மேலும் நிபந்தனைகளை பூர்த்தி செய்யாதவை புதிய பட்டியலில் இருந்து விலக்கப்படும்.

நிபந்தனையைப் பொறுத்து செயல்முறையை மாற்ற விரும்பினால், அல்லது நிபந்தனையைப் பூர்த்தி செய்யாத கூறுகளை வேறுவிதமாக செயலாக்க விரும்பினால், மும்மை ஆபரேட்டரைப் பயன்படுத்தவும்.

பைத்தானில், மும்மை ஆபரேட்டரை பின்வருமாறு எழுதலாம்

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() இன் எடுத்துக்காட்டு.

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)

பட்டியல் புரிதல் குறிப்பில் உள்ள சதுர அடைப்புக்குறிகளை [] சுருள் அடைப்புக்குறிகளாக மாற்றுவது {} ஒரு தொகுப்பை உருவாக்குகிறது (செட்-டைப் ஆப்ஜெக்ட்).

{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

ஜெனரேட்டர் வெளிப்பாடுகள் நிபந்தனைக்குட்பட்ட கிளைகள் மற்றும் கூடு கட்டுதல் ஆகியவற்றைப் பயன்படுத்தி, புரிந்துகொள்வதற்கான குறியீட்டைப் பட்டியலிடவும் அனுமதிக்கின்றன.

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