ਪਾਈਥਨ ਵਿੱਚ ਸਤਰ ਦੀ ਸੂਚੀ (ਐਰੇ) ਦੀਆਂ ਸ਼ਰਤਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਵਾਲੇ ਤੱਤਾਂ ਨੂੰ ਐਕਸਟਰੈਕਟ ਕਰਨਾ ਅਤੇ ਬਦਲਣਾ

ਇੱਕ ਸੂਚੀ (ਐਰੇ) ਤੋਂ ਇੱਕ ਨਵੀਂ ਸੂਚੀ ਬਣਾਉਣ ਲਈ ਜਿਸ ਦੇ ਤੱਤ ਸਤਰ ਹਨ, ਸਿਰਫ਼ ਕੁਝ ਸ਼ਰਤਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਵਾਲੇ ਸਤਰ ਦੇ ਤੱਤ ਕੱਢ ਕੇ, ਜਾਂ ਬਦਲ, ਪਰਿਵਰਤਨ, ਆਦਿ ਦੁਆਰਾ, ਸੂਚੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਸੂਚੀ ਦੀ ਸਮਝ ਦੀ ਇੱਕ ਸੰਖੇਪ ਵਿਆਖਿਆ ਤੋਂ ਬਾਅਦ, ਹੇਠਾਂ ਦਿੱਤੀ ਸਮੱਗਰੀ ਨੂੰ ਨਮੂਨਾ ਕੋਡ ਨਾਲ ਸਮਝਾਇਆ ਗਿਆ ਹੈ।

• ਕਿਸੇ ਖਾਸ ਸਤਰ ਨੂੰ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ ਜਾਂ ਨਹੀਂ ਇਸ ‘ਤੇ ਆਧਾਰਿਤ ਐਕਸਟਰੈਕਸ਼ਨ (ਅੰਸ਼ਕ ਮਿਲਾਨ)
• ਖਾਸ ਸਤਰ ਨੂੰ ਬਦਲੋ
• ਕਿਸੇ ਖਾਸ ਸਤਰ ਨਾਲ ਸ਼ੁਰੂ ਜਾਂ ਨਾ ਸ਼ੁਰੂ ਕਰਕੇ ਐਕਸਟਰੈਕਟ ਕਰੋ
• ਕਿਸੇ ਖਾਸ ਸਤਰ ਨਾਲ ਖਤਮ ਹੋਣ ਜਾਂ ਨਾ ਖਤਮ ਹੋਣ ਦੁਆਰਾ ਐਕਸਟਰੈਕਟ ਕਰੋ
• ਕੇਸ ਦੁਆਰਾ ਨਿਰਣਾ ਕੀਤਾ ਅਤੇ ਕੱਢਿਆ
• ਵੱਡੇ ਅਤੇ ਛੋਟੇ ਅੱਖਰਾਂ ਵਿੱਚ ਬਦਲੋ
• ਇਹ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਵਰਣਮਾਲਾ ਜਾਂ ਸੰਖਿਆਤਮਕ ਅੱਖਰ ਵਰਤੇ ਗਏ ਹਨ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਕੱਢਦਾ ਹੈ
• ਕਈ ਸ਼ਰਤਾਂ
• (ਕੰਪਿਊਟਰ) ਨਿਯਮਤ ਸਮੀਕਰਨ

ਨੋਟ ਕਰੋ ਕਿ ਸੂਚੀਆਂ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰ ਸਕਦੀਆਂ ਹਨ ਅਤੇ ਐਰੇ ਤੋਂ ਬਿਲਕੁਲ ਵੱਖਰੀਆਂ ਹਨ। ਜੇ ਤੁਸੀਂ ਉਹਨਾਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਐਰੇ ਨੂੰ ਸੰਭਾਲਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜਿਹਨਾਂ ਲਈ ਮੈਮੋਰੀ ਆਕਾਰ ਅਤੇ ਮੈਮੋਰੀ ਪਤੇ ਜਾਂ ਵੱਡੇ ਡੇਟਾ ਦੀ ਸੰਖਿਆਤਮਕ ਪ੍ਰਕਿਰਿਆ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਐਰੇ (ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ) ਜਾਂ NumPy ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਸੂਚੀ ਸੰਮਿਲਨ ਸੰਕੇਤ

ਜਦੋਂ ਇੱਕ ਸੂਚੀ ਤੋਂ ਇੱਕ ਨਵੀਂ ਸੂਚੀ ਤਿਆਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਲੂਪਸ ਲਈ ਸੂਚੀ ਦੀ ਸਮਝ ਲਿਖਣ ਲਈ ਆਸਾਨ ਹੁੰਦੀ ਹੈ।

• ਸੰਬੰਧਿਤ:ਪਾਈਥਨ ਸੂਚੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ

[expression for any variable name in iterable object if conditional expression]

ਜੇਕਰ ਤੱਤ ਨੂੰ ਸਿਰਫ ਇੱਕ ਸ਼ਰਤ ਸਮੀਕਰਨ ਦੁਆਰਾ ਚੁਣਿਆ ਜਾਣਾ ਹੈ, ਤਾਂ ਇਹ ਇੱਕ ਸਮੀਕਰਨ ਦੁਆਰਾ ਸੰਸਾਧਿਤ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਇਸਲਈ ਇਹ ਹੇਠਾਂ ਦਿੱਤਾ ਰੂਪ ਲੈਂਦਾ ਹੈ

[variable name for variable name in original list if conditional expression]

ਜੇਕਰ ਸ਼ਰਤੀਆ ਸਮੀਕਰਨ ਨੂੰ ਜੇਕਰ ਸ਼ਰਤੀਆ ਸਮੀਕਰਨ ਵਿੱਚ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਇੱਕ ਨੈਗੇਸ਼ਨ ਬਣ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਉਹ ਤੱਤ ਜੋ ਸ਼ਰਤੀਆ ਸਮੀਕਰਨ ਨੂੰ ਸੰਤੁਸ਼ਟ ਨਹੀਂ ਕਰਦੇ ਹਨ, ਕੱਢਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਇੱਕ ਖਾਸ ਸਤਰ (ਅੰਸ਼ਕ ਮਿਲਾਨ) ਰੱਖਦਾ ਹੈ \ ਨਹੀਂ ਰੱਖਦਾ:in

“ਮੂਲ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਖਾਸ ਸਤਰ” ਵਿੱਚ, ਜੇਕਰ ਅਸਲੀ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਖਾਸ ਸਟ੍ਰਿੰਗ ਸ਼ਾਮਲ ਹੈ ਤਾਂ True ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਹ ਇੱਕ ਸ਼ਰਤੀਆ ਸਮੀਕਰਨ ਹੈ।

in ਦੀ ਨਕਾਰਾਤਮਕਤਾ not in ਨਾਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

l = ['oneXXXaaa', 'twoXXXbbb', 'three999aaa', '000111222']

l_in = [s for s in l if 'XXX' in s]
print(l_in)
# ['oneXXXaaa', 'twoXXXbbb']

l_in_not = [s for s in l if 'XXX' not in s]
print(l_in_not)
# ['three999aaa', '000111222']

ਖਾਸ ਸਤਰ ਨੂੰ ਬਦਲੋ

ਜੇਕਰ ਤੁਸੀਂ ਸੂਚੀ ਤੱਤਾਂ ਦੀ ਇੱਕ ਸਤਰ ਨੂੰ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਵਿੱਚ ਹਰੇਕ ਤੱਤ ਲਈ ਸਟ੍ਰਿੰਗ ਵਿਧੀ ਬਦਲੋ() ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਜੇਕਰ ਬਦਲਣ ਲਈ ਕੋਈ ਸਤਰ ਨਹੀਂ ਹੈ, ਤਾਂ if ਕੰਡੀਸ਼ਨਲ ਸਮੀਕਰਨ ਵਿੱਚ ਐਲੀਮੈਂਟ ਦੀ ਚੋਣ ਕਰਨ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ ਕਿਉਂਕਿ ਇਸਨੂੰ replace() ਲਾਗੂ ਕਰਨ ਨਾਲ ਬਦਲਿਆ ਨਹੀਂ ਜਾਵੇਗਾ।

l_replace = [s.replace('XXX', 'ZZZ') for s in l]
print(l_replace)
# ['oneZZZaaa', 'twoZZZbbb', 'three999aaa', '000111222']

ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਪੂਰੇ ਐਲੀਮੈਂਟ ਨੂੰ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜਿਸ ਵਿੱਚ ਇੱਕ ਖਾਸ ਸਤਰ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਇਨ ਦੇ ਨਾਲ ਐਕਸਟਰੈਕਟ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਟਰਨਰੀ ਓਪਰੇਟਰ ਨਾਲ ਪ੍ਰੋਸੈਸ ਕਰੋ। ਟਰਨਰੀ ਆਪਰੇਟਰ ਹੇਠ ਲਿਖੇ ਰੂਪ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ।
True Value if Conditional Expression else False Value

ਇਹ ਠੀਕ ਹੈ ਜੇਕਰ ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਦਾ ਸਮੀਕਰਨ ਭਾਗ ਇੱਕ ਤੀਹਰਾ ਆਪਰੇਟਰ ਹੈ।

l_replace_all = ['ZZZ' if 'XXX' in s else s for s in l]
print(l_replace_all)
# ['ZZZ', 'ZZZ', 'three999aaa', '000111222']

ਹੇਠਾਂ ਦਿੱਤੇ ਨਤੀਜਿਆਂ ਦਾ ਸੰਖੇਪ ਹੈ, ਬਰੈਕਟਾਂ ਵਿੱਚ ਬੰਦ ਹੈ। ਜੇ ਤੁਸੀਂ ਬਰੈਕਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਆਦੀ ਨਹੀਂ ਹੋ, ਤਾਂ ਇਹ ਸਮਝਣਾ ਅਤੇ ਗਲਤੀਆਂ ਤੋਂ ਬਚਣਾ ਆਸਾਨ ਹੋ ਸਕਦਾ ਹੈ। ਵਿਆਕਰਨਿਕ ਤੌਰ ‘ਤੇ ਬਰੈਕਟ ਲਿਖਣ ‘ਤੇ ਵੀ ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਹੈ।

[('ZZZ' if ('XXX' in s) else s) for s in l]

ਇੱਕ ਸ਼ਰਤ ਦੇ ਤੌਰ ‘ਤੇ in ਦੀ ਵਰਤੋਂ ਸੂਚੀ ਦੀ ਸਮਝ ਸੰਕੇਤ ਦੇ ਨਾਲ ਉਲਝਣ ਵਾਲੀ ਹੈ, ਪਰ ਇਹ ਮੁਸ਼ਕਲ ਨਹੀਂ ਹੈ ਜੇਕਰ ਤੁਸੀਂ ਸੂਚੀ ਸਮਝੌਤਾ ਨੋਟੇਸ਼ਨ ਅਤੇ ਟਰਨਰੀ ਓਪਰੇਟਰਾਂ ਦੇ ਸਿੰਟੈਕਟਿਕ ਰੂਪ ਤੋਂ ਜਾਣੂ ਹੋ।

ਇੱਕ ਖਾਸ ਸਤਰ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ \ ਸ਼ੁਰੂ ਨਹੀਂ ਹੁੰਦਾ:startswith()

ਸਟਰਿੰਗ ਵਿਧੀ startswith() ਸਹੀ ਵਾਪਸ ਆਉਂਦੀ ਹੈ ਜੇਕਰ ਸਟਰਿੰਗ ਆਰਗੂਮੈਂਟ ਵਿੱਚ ਦਰਸਾਏ ਗਏ ਸਤਰ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ।

l_start = [s for s in l if s.startswith('t')]
print(l_start)
# ['twoXXXbbb', 'three999aaa']

l_start_not = [s for s in l if not s.startswith('t')]
print(l_start_not)
# ['oneXXXaaa', '000111222']

ਇੱਕ ਖਾਸ ਅੱਖਰ ਸਤਰ ਦੇ ਨਾਲ ਖਤਮ ਹੁੰਦਾ ਹੈ \ ਨਾ ਅੰਤ:endswith()

ਸਟ੍ਰਿੰਗ ਵਿਧੀ endswith() ਸਹੀ ਵਾਪਸ ਆਉਂਦੀ ਹੈ ਜੇਕਰ ਸਟ੍ਰਿੰਗ ਆਰਗੂਮੈਂਟ ਵਿੱਚ ਦਰਸਾਏ ਗਏ ਸਤਰ ਨਾਲ ਖਤਮ ਹੁੰਦੀ ਹੈ।

l_end = [s for s in l if s.endswith('aaa')]
print(l_end)
# ['oneXXXaaa', 'three999aaa']

l_end_not = [s for s in l if not s.endswith('aaa')]
print(l_end_not)
# ['twoXXXbbb', '000111222']

ਕੇਸ ਦੁਆਰਾ ਨਿਰਣਾ ਕੀਤਾ ਅਤੇ ਕੱਢਿਆ

ਸਤਰ ਵਿਧੀਆਂ isupper(),islower() ਦੀ ਵਰਤੋਂ ਇਹ ਨਿਰਧਾਰਿਤ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਕਿ ਕੀ ਇੱਕ ਸਟ੍ਰਿੰਗ ਸਭ ਤੋਂ ਉੱਪਰ ਹੈ ਜਾਂ ਸਾਰੇ ਲੋਅਰ ਕੇਸ।

l_lower = [s for s in l if s.islower()]
print(l_lower)
# ['three999aaa']

ਵੱਡੇ ਅਤੇ ਛੋਟੇ ਅੱਖਰਾਂ ਵਿੱਚ ਬਦਲੋ

ਜੇਕਰ ਤੁਸੀਂ ਸਾਰੇ ਅੱਖਰਾਂ ਨੂੰ ਵੱਡੇ ਜਾਂ ਛੋਟੇ ਅੱਖਰਾਂ ਵਿੱਚ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਸਟ੍ਰਿੰਗ ਵਿਧੀਆਂ upper() ਅਤੇ Lower() ਦੀ ਵਰਤੋਂ ਕਰੋ। ਹੋਰ ਤਰੀਕਿਆਂ ਵਿੱਚ ਵੱਡੇ ਅਤੇ ਛੋਟੇ ਅੱਖਰਾਂ ਦੀ ਅਦਲਾ-ਬਦਲੀ ਕਰਨ ਵਾਲੇ ਕੈਪੀਟਲਾਈਜ਼ (), ਜੋ ਸਿਰਫ ਪਹਿਲੇ ਅੱਖਰ ਨੂੰ ਵੱਡੇ ਅੱਖਰ ਅਤੇ ਸਵੈਪਕੇਸ (), ਸ਼ਾਮਲ ਕਰਦੇ ਹਨ।

ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦਿੱਤੀ ਗਈ ਬਦਲੀ ਦੀ ਉਦਾਹਰਨ ਵਿੱਚ, ਜੇ ਤੁਸੀਂ ਸਿਰਫ਼ ਉਹਨਾਂ ਤੱਤਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਜੋ ਸ਼ਰਤ ਨੂੰ ਸੰਤੁਸ਼ਟ ਕਰਦੇ ਹਨ ਤਾਂ ਟਰਨਰੀ ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰੋ।

l_upper_all = [s.upper() for s in l]
print(l_upper_all)
# ['ONEXXXAAA', 'TWOXXXBBB', 'THREE999AAA', '000111222']

l_lower_to_upper = [s.upper() if s.islower() else s for s in l]
print(l_lower_to_upper)
# ['oneXXXaaa', 'twoXXXbbb', 'THREE999AAA', '000111222']

ਇਹ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਵਰਣਮਾਲਾ ਜਾਂ ਸੰਖਿਆਤਮਕ ਅੱਖਰ ਵਰਤੇ ਗਏ ਹਨ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਕੱਢਦਾ ਹੈ

ਸਤਰ ਵਿਧੀਆਂ isalpha() ਅਤੇ isnumeric() ਦੀ ਵਰਤੋਂ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਕਿ ਕੀ ਇੱਕ ਸਤਰ ਸਾਰੇ ਵਰਣਮਾਲਾ, ਸੰਖਿਆਤਮਕ, ਆਦਿ ਹੈ।

l_isalpha = [s for s in l if s.isalpha()]
print(l_isalpha)
# ['oneXXXaaa', 'twoXXXbbb']

l_isnumeric = [s for s in l if s.isnumeric()]
print(l_isnumeric)
# ['000111222']

ਕਈ ਸ਼ਰਤਾਂ

ਸੂਚੀ ਸਮਝ ਦਾ ਕੰਡੀਸ਼ਨਲ ਸਮੀਕਰਨ ਹਿੱਸਾ ਕਈ ਸ਼ਰਤਾਂ ਹੋ ਸਕਦਾ ਹੈ। ਨਕਾਰਾਤਮਕ “ਨਹੀਂ” ਸਥਿਤੀਆਂ ਨੂੰ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ.

ਤਿੰਨ ਜਾਂ ਵਧੇਰੇ ਕੰਡੀਸ਼ਨਲ ਸਮੀਕਰਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਹਰੇਕ ਸਮੂਹ ਨੂੰ ਬਰੈਕਟ () ਵਿੱਚ ਨੱਥੀ ਕਰਨਾ ਸੁਰੱਖਿਅਤ ਹੁੰਦਾ ਹੈ ਕਿਉਂਕਿ ਨਤੀਜਾ ਕ੍ਰਮ ਦੇ ਆਧਾਰ ‘ਤੇ ਵੱਖ-ਵੱਖ ਹੋਵੇਗਾ।

l_multi = [s for s in l if s.isalpha() and not s.startswith('t')]
print(l_multi)
# ['oneXXXaaa']

l_multi_or = [s for s in l if (s.isalpha() and not s.startswith('t')) or ('bbb' in s)]
print(l_multi_or)
# ['oneXXXaaa', 'twoXXXbbb']

(ਕੰਪਿਊਟਰ) ਨਿਯਮਤ ਸਮੀਕਰਨ

ਨਿਯਮਤ ਸਮੀਕਰਨ ਬਹੁਤ ਹੀ ਲਚਕਦਾਰ ਪ੍ਰੋਸੈਸਿੰਗ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ।

ਮੇਲ ਆਬਜੈਕਟ re.match() ਦੁਆਰਾ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਇਹ ਮੇਲ ਖਾਂਦਾ ਹੈ ਜਦੋਂ ਕਿਸੇ ਸ਼ਰਤੀਆ ਸਮੀਕਰਨ ਨਾਲ ਮੁਲਾਂਕਣ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਇਹ ਹਮੇਸ਼ਾ ਸਹੀ ਹੋਣ ਲਈ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਜੇਕਰ ਇਹ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ, ਤਾਂ ਇਹ None ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜੋ ਕੰਡੀਸ਼ਨਲ ਸਮੀਕਰਨ ਵਿੱਚ ਗਲਤ ਹੈ। ਇਸ ਲਈ, ਜੇਕਰ ਤੁਸੀਂ ਸਿਰਫ਼ ਉਹ ਤੱਤ ਕੱਢਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜੋ ਰੈਗੂਲਰ ਸਮੀਕਰਨ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ, ਤਾਂ ਪਹਿਲਾਂ ਵਾਂਗ ਸੂਚੀ ਸਮਝ ਸਮੀਕਰਨ ਦੇ ਕੰਡੀਸ਼ਨਲ ਸਮੀਕਰਨ ਵਾਲੇ ਹਿੱਸੇ ‘ਤੇ re.match() ਨੂੰ ਲਾਗੂ ਕਰੋ।

import re

l = ['oneXXXaaa', 'twoXXXbbb', 'three999aaa', '000111222']

l_re_match = [s for s in l if re.match('.*XXX.*', s)]
print(l_re_match)
# ['oneXXXaaa', 'twoXXXbbb']

re.sub(), ਜੋ ਕਿ ਨਿਯਮਤ ਸਮੀਕਰਨ ਦੇ ਮੇਲ ਵਾਲੇ ਹਿੱਸੇ ਨੂੰ ਬਦਲਦਾ ਹੈ, ਵੀ ਲਾਭਦਾਇਕ ਹੈ। ਸਿਰਫ਼ ਮੇਲ ਖਾਂਦੇ ਤੱਤਾਂ ਨੂੰ ਐਕਸਟਰੈਕਟ ਕਰਨ ਅਤੇ ਬਦਲਣ ਲਈ, ਸਿਰਫ਼ “ਜੇ ਕੰਡੀਸ਼ਨਲ ਸਮੀਕਰਨ” ਸ਼ਾਮਲ ਕਰੋ।

l_re_sub_all = [re.sub('(.*)XXX(.*)', r'\2---\1', s) for s in l]
print(l_re_sub_all)
# ['aaa---one', 'bbb---two', 'three999aaa', '000111222']

l_re_sub = [re.sub('(.*)XXX(.*)', r'\2---\1', s) for s in l if re.match('.*XXX.*', s)]
print(l_re_sub)
# ['aaa---one', 'bbb---two']