ਪਾਈਥਨ ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਕਾਰੋਬਾਰ

ਪਾਈਥਨ ਵਿੱਚ, ਇੱਕ ਨਵੀਂ ਸੂਚੀ ਬਣਾਉਣ ਵੇਲੇ ਸੂਚੀ ਦੀ ਸਮਝ ਦੇ ਸੰਕੇਤ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸਧਾਰਨ ਹੈ।(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 ਨੂੰ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਲਿਖੋ।

[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() ਨਾਲ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਪਰ ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਨੂੰ ਇਸਦੀ ਸਰਲਤਾ ਅਤੇ ਸਪਸ਼ਟਤਾ ਲਈ ਤਰਜੀਹ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ।

ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਨਾਲ ਸੁਮੇਲ (ਜੇਕਰ ਹੋਰ-ਵਰਗੇ ਪ੍ਰੋਸੈਸਿੰਗ)

ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਵਿੱਚ, ਸਿਰਫ਼ ਉਹਨਾਂ ਤੱਤਾਂ ‘ਤੇ ਕਾਰਵਾਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜੋ ਮਾਪਦੰਡਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦੇ ਹਨ, ਅਤੇ ਜਿਹੜੇ ਮਾਪਦੰਡ ਪੂਰੇ ਨਹੀਂ ਕਰਦੇ ਹਨ ਉਹਨਾਂ ਨੂੰ ਨਵੀਂ ਸੂਚੀ ਵਿੱਚੋਂ ਬਾਹਰ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ।

ਜੇਕਰ ਤੁਸੀਂ ਸਥਿਤੀ ‘ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਜਾਂ ਜੇ ਤੁਸੀਂ ਉਹਨਾਂ ਤੱਤਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਜੋ ਸਥਿਤੀ ਨੂੰ ਵੱਖਰੇ ਤੌਰ ‘ਤੇ ਸੰਤੁਸ਼ਟ ਨਹੀਂ ਕਰਦੇ, ਜਿਵੇਂ ਕਿ ਹੋਰ, ਟਰਨਰੀ ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਪਾਈਥਨ ਵਿੱਚ, ਟਰਨਰੀ ਓਪਰੇਟਰ ਨੂੰ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ

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() ਦੇ ਨਾਲ ਸੁਮੇਲ

ਉਪਯੋਗੀ ਫੰਕਸ਼ਨ ਜੋ ਅਕਸਰ for ਸਟੇਟਮੈਂਟ ਵਿੱਚ ਵਰਤੇ ਜਾਂਦੇ ਹਨ, ਵਿੱਚ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ zip(), ਜੋ ਕਿ ਮਲਟੀਪਲ ਰੀਟਰੇਬਲ ਨੂੰ ਜੋੜਦਾ ਹੈ, ਅਤੇ enumerate(), ਜੋ ਇਸਦੇ ਸੂਚਕਾਂਕ ਦੇ ਨਾਲ ਇੱਕ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਬੇਸ਼ੱਕ, ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਦੇ ਨਾਲ zip() ਅਤੇ enumerate() ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸੰਭਵ ਹੈ। ਇਹ ਕੋਈ ਵਿਸ਼ੇਸ਼ ਸੰਟੈਕਸ ਨਹੀਂ ਹੈ, ਅਤੇ ਇਹ ਮੁਸ਼ਕਲ ਨਹੀਂ ਹੈ ਜੇਕਰ ਤੁਸੀਂ for ਸਟੇਟਮੈਂਟ ਦੇ ਨਾਲ ਪੱਤਰ ਵਿਹਾਰ ਨੂੰ ਵਿਚਾਰਦੇ ਹੋ।

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

ਜਿਵੇਂ ਕਿ ਪ੍ਰੋਸੈਸਿੰਗ ਸਪੀਡ ਲਈ, ਸੂਚੀ ਦੀ ਸਮਝ ਨੋਟੇਸ਼ਨ ਅਕਸਰ ਜਨਰੇਟਰ ਸੰਕੇਤ ਨਾਲੋਂ ਤੇਜ਼ ਹੁੰਦੀ ਹੈ ਜਦੋਂ ਸਾਰੇ ਤੱਤਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਹਾਲਾਂਕਿ, ਜਦੋਂ all() ਜਾਂ any(), ਉਦਾਹਰਨ ਲਈ, ਨਤੀਜਾ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਗਲਤ ਜਾਂ ਸਹੀ ਮੌਜੂਦ ਹੁੰਦਾ ਹੈ, ਇਸਲਈ ਜਨਰੇਟਰ ਸਮੀਕਰਨਾਂ ਦੀ ਵਰਤੋਂ ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਦੀ ਵਰਤੋਂ ਕਰਨ ਨਾਲੋਂ ਤੇਜ਼ ਹੋ ਸਕਦੀ ਹੈ।

ਇੱਥੇ ਕੋਈ ਟੂਪਲ ਕੰਪਰੀਹੈਂਸ਼ਨ ਨੋਟੇਸ਼ਨ ਨਹੀਂ ਹੈ, ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਟੂਪਲ() ਦੀ ਇੱਕ ਦਲੀਲ ਦੇ ਤੌਰ ਤੇ ਇੱਕ ਜਨਰੇਟਰ ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਸਮਝ ਸੰਕੇਤ ਵਿੱਚ ਇੱਕ ਟੂਪਲ ਤਿਆਰ ਕਰ ਸਕਦੇ ਹੋ।

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

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

print(type(t))
# <class 'tuple'>