ਪਾਈਥਨ, ਕੌਮੇ ਨਾਲ ਵੱਖ ਕੀਤੀ ਸਟ੍ਰਿੰਗ ਨੂੰ ਵੰਡਣ ਲਈ ਸਪਲਿਟ ਕਰੋ, ਵ੍ਹਾਈਟਸਪੇਸ ਹਟਾਓ ਅਤੇ ਸੂਚੀ ਵਿੱਚ ਬਦਲੋ

ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਸੂਚੀ ਵਿੱਚ ਕਾਮੇ ਨਾਲ ਵੱਖ ਕੀਤੀ ਸਤਰ ਨੂੰ ਵੰਡਣ ਵੇਲੇ, ਜੇਕਰ ਵਿਚਕਾਰ ਕੋਈ ਖਾਲੀ ਥਾਂ ਨਹੀਂ ਹੈ, ਤਾਂ ਸਿਰਫ਼ split() ਕੰਮ ਕਰੇਗਾ। ਜੇਕਰ ਖਾਲੀ ਥਾਂਵਾਂ ਹਨ, ਤਾਂ ਵਾਧੂ ਖਾਲੀ ਥਾਂਵਾਂ ਨੂੰ ਹਟਾਉਣ ਲਈ ਇਸ ਨੂੰ strip() ਨਾਲ ਜੋੜਨਾ ਲਾਭਦਾਇਕ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਲਿਖਣ ਦਾ ਇੱਕ ਸਮਾਰਟ ਤਰੀਕਾ ਹੈ।

ਇਸ ਭਾਗ ਵਿੱਚ, ਅਸੀਂ ਪਹਿਲਾਂ ਹੇਠਾਂ ਦਿੱਤੀ ਵਿਆਖਿਆ ਕਰਦੇ ਹਾਂ।

• ਇੱਕ ਸਤਰ ਨੂੰ ਇੱਕ ਨਿਸ਼ਚਿਤ ਡੀਲੀਮੀਟਰ ਨਾਲ ਵੰਡੋ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਸੂਚੀ ਦੇ ਰੂਪ ਵਿੱਚ ਵਾਪਸ ਕਰੋsplit()
• ਇੱਕ ਸਤਰ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਤੋਂ ਵਾਧੂ ਅੱਖਰ ਹਟਾਓ।strip()
• ਤੱਤਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਵਿਧੀਆਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਸੂਝ-ਬੂਝ ਸੰਕੇਤ ਦੀ ਸੂਚੀ ਬਣਾਓ।

ਇਹ ਇਹ ਵੀ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਖਾਲੀ ਥਾਂਵਾਂ ਨੂੰ ਹਟਾ ਕੇ ਸਪੇਸ ਅਤੇ ਕਾਮਿਆਂ ਨਾਲ ਵੱਖ ਕੀਤੀਆਂ ਸਤਰਾਂ ਦੀ ਸੂਚੀ ਕਿਵੇਂ ਬਣਾਈ ਜਾਵੇ, ਜਿਵੇਂ ਕਿ ਹੇਠਾਂ ਦਿਖਾਇਆ ਗਿਆ ਹੈ।
one, two, three'

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਅਸੀਂ ਹੇਠਾਂ ਦਿੱਤੀ ਚਰਚਾ ਕਰਾਂਗੇ

• ਸੰਖਿਆਵਾਂ ਦੀ ਸੂਚੀ ਦੇ ਰੂਪ ਵਿੱਚ ਇਸਨੂੰ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ
• ਇੱਕ ਸੂਚੀ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਣ ਅਤੇ ਇਸਨੂੰ ਦੁਬਾਰਾ ਇੱਕ ਸਤਰ ਬਣਾਉਣ ਲਈ join() ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ

split():ਇੱਕ ਸਤਰ ਨੂੰ ਇੱਕ ਨਿਸ਼ਚਿਤ ਡੀਲੀਮੀਟਰ ਨਾਲ ਵੰਡੋ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਸੂਚੀ ਦੇ ਰੂਪ ਵਿੱਚ ਵਾਪਸ ਕਰੋ

ਸਤਰ ਲਈ ਵਿਧੀ split() ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਤੁਸੀਂ ਇੱਕ ਨਿਰਧਾਰਤ ਡੈਲੀਮੀਟਰ ਨਾਲ ਇੱਕ ਸਤਰ ਨੂੰ ਵੰਡ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਸੂਚੀ (ਐਰੇ) ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ। ਨਿਸ਼ਚਿਤ ਡੀਲੀਮੀਟਰ ਨੂੰ ਨਿਮਨਲਿਖਤ ਆਰਗੂਮੈਂਟ ਦੁਆਰਾ ਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।sep

• str.split() — Built-in Types — Python 3.10.1 Documentation

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

s = 'one two three'
l = s.split()
print(l)
# ['one', 'two', 'three']

s = 'one two        three'
l = s.split()
print(l)
# ['one', 'two', 'three']

s = 'one\ttwo\tthree'
l = s.split()
print(l)
# ['one', 'two', 'three']

ਜੇਕਰ sep ਆਰਗੂਮੈਂਟ ਵਿੱਚ ਇੱਕ ਡੀਲੀਮੀਟਰ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਇਹ ਸੂਚੀ ਨੂੰ ਉਸ ਸਤਰ ਦੁਆਰਾ ਵੰਡਦਾ ਹੈ ਅਤੇ ਇੱਕ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ।

s = 'one::two::three'
l = s.split('::')
print(l)
# ['one', 'two', 'three']

ਕਾਮੇ ਨਾਲ ਵੱਖ ਕੀਤੀ ਸਟ੍ਰਿੰਗ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਜੇਕਰ ਕੋਈ ਵਾਧੂ ਸਫੈਦ ਥਾਂ ਨਹੀਂ ਹੈ, ਤਾਂ ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਹੈ, ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਕਾਮੇ ਨਾਲ ਵੱਖ ਕੀਤੀ ਸਤਰ ਦੇ ਸੀਮਾਕਾਰ ਵਜੋਂ split() ਨੂੰ ਕਾਮੇ + ਵਾਈਟ ਸਪੇਸ ਨਾਲ ਵੱਖ ਕੀਤਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਖਤਮ ਹੋ ਜਾਵੋਗੇ। ਸ਼ੁਰੂ ਵਿੱਚ ਛੱਡੀ ਗਈ ਸਫੈਦ ਸਪੇਸ ਵਾਲੀ ਸਤਰ ਦੀ ਸੂਚੀ ਦੇ ਨਾਲ ਉੱਪਰ।

s = 'one,two,three'
l = s.split(',')
print(l)
# ['one', 'two', 'three']

s = 'one, two, three'
l = s.split(',')
print(l)
# ['one', ' two', ' three']

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

s = 'one, two, three'
l = s.split(', ')
print(l)
# ['one', 'two', 'three']

s = 'one, two,  three'
l = s.split(', ')
print(l)
# ['one', 'two', ' three']

ਸਟ੍ਰਿੰਗ ਵਿਧੀ ਸਟ੍ਰਿਪ(), ਜਿਸਦੀ ਅੱਗੇ ਵਿਆਖਿਆ ਕੀਤੀ ਜਾਵੇਗੀ, ਨੂੰ ਦੋ ਸਪੇਸ ਨਾਲ ਨਜਿੱਠਣ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

strip():ਇੱਕ ਸਤਰ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਤੋਂ ਵਾਧੂ ਅੱਖਰ ਹਟਾਓ।

strip() ਇੱਕ ਸਤਰ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਤੋਂ ਵਾਧੂ ਅੱਖਰਾਂ ਨੂੰ ਹਟਾਉਣ ਦਾ ਇੱਕ ਤਰੀਕਾ ਹੈ।

• str.strip() — Built-in Types — Python 3.10.1 Documentation

ਜੇਕਰ ਆਰਗੂਮੈਂਟ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਵ੍ਹਾਈਟਸਪੇਸ ਅੱਖਰਾਂ ਨੂੰ ਹਟਾ ਕੇ ਇੱਕ ਨਵੀਂ ਸਤਰ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ। ਅਸਲੀ ਸਤਰ ਆਪਣੇ ਆਪ ਨੂੰ ਬਦਲਿਆ ਨਹੀ ਹੈ.

s = '  one  '
print(s.strip())
# one

print(s)
#   one  

ਜੇਕਰ ਇੱਕ ਸਤਰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ ‘ਤੇ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਸਤਰ ਵਿੱਚ ਮੌਜੂਦ ਅੱਖਰ ਹਟਾ ਦਿੱਤੇ ਜਾਣਗੇ।

s = '-+-one-+-'
print(s.strip('-+'))
# one

ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਖਾਲੀ ਥਾਂਵਾਂ ਨੂੰ ਹਟਾਇਆ ਨਹੀਂ ਜਾਂਦਾ. ਇਸਲਈ, ਜੇਕਰ ਤੁਸੀਂ ਵ੍ਹਾਈਟਸਪੇਸ ਨੂੰ ਵੀ ਹਟਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇੱਕ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ ਤੇ ਸਪੇਸ ਸਮੇਤ ਇੱਕ ਸਤਰ ਪਾਸ ਕਰੋ, ਜਿਵੇਂ ਕਿ ਹੇਠਾਂ ਦਿਖਾਇਆ ਗਿਆ ਹੈ।-+ '

s = '-+- one -+-'
print(s.strip('-+'))
#  one 

s = '-+- one -+-'
print(s.strip('-+ '))
# one

strip() ਦੋਵਾਂ ਸਿਰਿਆਂ ਨੂੰ ਹੈਂਡਲ ਕਰਦਾ ਹੈ, ਪਰ ਹੇਠਾਂ ਦਿੱਤੇ ਫੰਕਸ਼ਨ ਵੀ ਉਪਲਬਧ ਹਨ।

• lstrip():ਪ੍ਰਕਿਰਿਆ ਸਿਰਫ ਸ਼ੁਰੂਆਤ ਹੈ
• rstrip():ਸਿਰਫ਼ ਲਾਈਨ ਦੇ ਅੰਤ ‘ਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰੋ।

ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ: ਸੂਚੀ ਤੱਤਾਂ ਲਈ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਵਿਧੀਆਂ ਨੂੰ ਲਾਗੂ ਕਰੋ

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

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

ਇੱਥੇ, ਅਸੀਂ strip() ਨੂੰ split() ਨਾਲ ਸਟ੍ਰਿੰਗ ਨੂੰ ਵੰਡ ਕੇ ਪ੍ਰਾਪਤ ਕੀਤੀ ਸੂਚੀ ਵਿੱਚ ਲਾਗੂ ਕਰਦੇ ਹਾਂ। ਇੱਕ ਸੂਚੀ ਬਣਾਉਣ ਲਈ ਕਾਮੇ ਨਾਲ ਵੱਖ ਕੀਤੀ ਸਤਰ ਵਿੱਚ ਵਾਧੂ ਖਾਲੀ ਥਾਂ ਨੂੰ ਹਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।

s = 'one, two, three'
l = [x.strip() for x in s.split(',')]
print(l)
# ['one', 'two', 'three']

ਜਦੋਂ ਇਸਨੂੰ ਇੱਕ ਖਾਲੀ ਸਤਰ ਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇੱਕ ਤੱਤ ਦੇ ਰੂਪ ਵਿੱਚ ਇੱਕ ਖਾਲੀ ਸਤਰ ਵਾਲੀ ਸੂਚੀ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

s = ''
l = [x.strip() for x in s.split(',')]
print(l)
print(len(l))
# ['']
# 1

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

s = ''
l = [x.strip() for x in s.split(',') if not s == '']
print(l)
print(len(l))
# []
# 0

one, , three'
ਨਾਲ ਹੀ, ਜੇਕਰ ਇੱਕ ਕੌਮੇ ਨਾਲ ਵੱਖ ਕੀਤਾ ਐਲੀਮੈਂਟ ਗੁੰਮ ਹੈ, ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਪਹਿਲੀ ਵਿਧੀ ਇਸਨੂੰ ਇੱਕ ਖਾਲੀ ਸਤਰ ਤੱਤ ਵਜੋਂ ਸੂਚੀਬੱਧ ਕਰੇਗੀ।

s = 'one, , three'
l = [x.strip() for x in s.split(',')]
print(l)
print(len(l))
# ['one', '', 'three']
# 3

ਜੇਕਰ ਤੁਸੀਂ ਗੁੰਮ ਹੋਏ ਹਿੱਸਿਆਂ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਸੂਚੀ ਸਮਝ ਦੇ ਸੰਕੇਤ ਵਿੱਚ ਇੱਕ ਸ਼ਰਤ ਸ਼ਾਖਾ ਸਥਾਪਤ ਕਰ ਸਕਦੇ ਹੋ।

s = 'one, ,three'
l = [x.strip() for x in s.split(',') if not x.strip() == '']
print(l)
print(len(l))
# ['one', 'three']
# 2

ਸੰਖਿਆਵਾਂ ਦੀ ਸੂਚੀ ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕਰੋ

ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਸਟ੍ਰਿੰਗ ਦੀ ਬਜਾਏ ਸੰਖਿਆਵਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਦੇ ਤੌਰ ‘ਤੇ ਕੌਮੇ ਨਾਲ ਵੱਖ ਕੀਤੀ ਸਤਰ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਵਿੱਚ ਸਟ੍ਰਿੰਗ ਨੂੰ ਇੱਕ ਨੰਬਰ ਵਿੱਚ ਬਦਲਣ ਲਈ int() ਜਾਂ float() ਲਾਗੂ ਕਰੋ।

s = '1, 2, 3, 4'
l = [x.strip() for x in s.split(',')]
print(l)
print(type(l[0]))
# ['1', '2', '3', '4']
# <class 'str'>

s = '1, 2, 3, 4'
l = [int(x.strip()) for x in s.split(',')]
print(l)
print(type(l[0]))
# [1, 2, 3, 4]
# <class 'int'>

join():ਇੱਕ ਸੂਚੀ ਨੂੰ ਮਿਲਾਓ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕਰੋ

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

• str.join() — Built-in Types — Python 3.10.1 Documentation

ਗਲਤੀ ਕਰਨਾ ਆਸਾਨ ਹੈ, ਪਰ ਯਾਦ ਰੱਖੋ ਕਿ join() ਇੱਕ ਸਤਰ ਵਿਧੀ ਹੈ, ਸੂਚੀ ਵਿਧੀ ਨਹੀਂ। ਸੂਚੀ ਇੱਕ ਦਲੀਲ ਦੇ ਤੌਰ ਤੇ ਦਰਸਾਈ ਗਈ ਹੈ।

s = 'one, two,  three'
l = [x.strip() for x in s.split(',')]
print(l)
# ['one', 'two', 'three']

print(','.join(l))
# one,two,three

print('::'.join(l))
# one::two::three

ਤੁਸੀਂ ਇਸਨੂੰ ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਲਿਖ ਸਕਦੇ ਹੋ।

s = 'one, two,  three'
s_new = '-'.join([x.strip() for x in s.split(',')])
print(s_new)
# one-two-three

ਜੇਕਰ ਤੁਸੀਂ ਸਿਰਫ਼ ਇੱਕ ਫਿਕਸਡ ਡੀਲੀਮੀਟਰ ਨੂੰ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇਸਨੂੰ ਬਦਲੋ() ਵਿਧੀ ਨਾਲ ਬਦਲਣਾ ਆਸਾਨ ਹੈ।

s = 'one,two,three'
s_new = s.replace(',', '+')
print(s_new)
# one+two+three