ਪਾਈਥਨ ਵਿੱਚ ਤਾਰਾਂ ਨੂੰ ਜੋੜਨਾ ਅਤੇ ਜੋੜਨਾ: + ਆਪਰੇਟਰ, ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋ, ਆਦਿ।

ਹੇਠਾਂ ਪਾਈਥਨ ਵਿੱਚ ਸਟ੍ਰਿੰਗ ਸਟ੍ਰਿੰਗ ਨੂੰ ਜੋੜਨ ਅਤੇ ਜੋੜਨ ਦੇ ਤਰੀਕੇ ਦਾ ਵਰਣਨ ਹੈ।

• ਕਈ ਸਟ੍ਰਿੰਗਾਂ ਨੂੰ ਜੋੜਨਾ ਅਤੇ ਮਿਲਾਉਣਾ:+,+=ਆਪਰੇਟਰ
• ਸੰਖਿਆਵਾਂ ਅਤੇ ਤਾਰਾਂ ਨੂੰ ਜੋੜੋ ਅਤੇ ਜੋੜੋ:+,+=ਆਪਰੇਟਰ,str(),format(),f-ਸਤਰ
• ਇੱਕ ਸਿੰਗਲ ਸਤਰ ਵਿੱਚ ਸਟਰਿੰਗਾਂ ਦੀਆਂ ਸੂਚੀਆਂ (ਐਰੇ) ਨੂੰ ਜੋੜੋ ਅਤੇ ਜੋੜੋ:join()
• ਸੰਖਿਆਵਾਂ ਦੀਆਂ ਸੂਚੀਆਂ (ਐਰੇ) ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਸਤਰ ਵਿੱਚ ਜੋੜੋ ਅਤੇ ਜੋੜੋ:join(),str()

ਕਈ ਸਟ੍ਰਿੰਗਾਂ ਨੂੰ ਜੋੜਨਾ ਅਤੇ ਮਿਲਾਉਣਾ:+,+=ਆਪਰੇਟਰ

ਕੁਨੈਕਸ਼ਨ:+ਆਪਰੇਟਰ

++ ਆਪਰੇਟਰ ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਸਟ੍ਰਿੰਗ ਲਿਟਰਲ ਅਤੇ ਸਟ੍ਰਿੰਗ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਜੋੜਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ

• …’
• “…”

s = 'aaa' + 'bbb' + 'ccc'
print(s)
# aaabbbccc

s1 = 'aaa'
s2 = 'bbb'
s3 = 'ccc'

s = s1 + s2 + s3
print(s)
# aaabbbccc

s = s1 + s2 + s3 + 'ddd'
print(s)
# aaabbbcccddd

ਕੁਨੈਕਸ਼ਨ:+=ਆਪਰੇਟਰ

+= ਆਪਰੇਟਰ, ਇੱਕ ਸੰਚਤ ਅਸਾਈਨਮੈਂਟ ਆਪਰੇਟਰ, ਨੂੰ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਖੱਬੇ-ਹੱਥ ਵਾਲੇ ਪਾਸੇ ਸਟ੍ਰਿੰਗ ਵੇਰੀਏਬਲ ਨੂੰ ਸੱਜੇ-ਹੱਥ ਵਾਲੇ ਪਾਸੇ ਵਾਲੀ ਸਤਰ ਨਾਲ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਨਿਰਧਾਰਤ ਅਤੇ ਅੱਪਡੇਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

s1 += s2
print(s1)
# aaabbb

ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਸਟ੍ਰਿੰਗ ਵੇਰੀਏਬਲ ਦੇ ਅੰਤ ਵਿੱਚ ਇੱਕ ਸਟ੍ਰਿੰਗ ਜੋੜਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਬਸ += ਆਪਰੇਟਰ ਨਾਲ ਸਟ੍ਰਿੰਗ ਵੇਰੀਏਬਲ ਅਤੇ ਕਿਸੇ ਵੀ ਸਟ੍ਰਿੰਗ ਲਿਟਰਲ (ਜਾਂ ਕੋਈ ਹੋਰ ਸਟ੍ਰਿੰਗ ਵੇਰੀਏਬਲ) ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰੋ।

s = 'aaa'

s += 'xxx'
print(s)
# aaaxxx

ਸਟ੍ਰਿੰਗ ਲਿਟਰਲ ਦਾ ਲਗਾਤਾਰ ਜੋੜ

ਜੇਕਰ ਤੁਸੀਂ ਸਿਰਫ਼ ਸਟ੍ਰਿੰਗ ਲਿਟਰਲ ਨੂੰ ਨਾਲ-ਨਾਲ ਲਿਖਦੇ ਹੋ, ਤਾਂ ਸਟ੍ਰਿੰਗ ਲਿਟਰਲ ਨੂੰ ਜੋੜਿਆ ਜਾਵੇਗਾ।

s = 'aaa''bbb''ccc'
print(s)
# aaabbbccc

ਦੋ ਲਾਈਨਾਂ ਜਾਂ ਬੈਕਸਲੈਸ਼ ਲਾਈਨ ਬ੍ਰੇਕ (ਇੱਕ ਨਿਰੰਤਰਤਾ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ) ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਸਪੇਸ ਰੱਖਣਾ ਸਵੀਕਾਰਯੋਗ ਹੈ।

s = 'aaa'  'bbb'    'ccc'
print(s)
# aaabbbccc

s = 'aaa'\
    'bbb'\
    'ccc'
print(s)
# aaabbbccc

ਕੋਡ ਵਿੱਚ ਕਈ ਲਾਈਨਾਂ ਉੱਤੇ ਲੰਬੀਆਂ ਸਤਰ ਲਿਖਣ ਲਈ ਇਸਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇੱਕ ਤਕਨੀਕ ਹੈ।

• ਸੰਬੰਧਿਤ ਲੇਖ:ਪਾਈਥਨ ਵਿੱਚ ਮਲਟੀਪਲ ਲਾਈਨਾਂ ਉੱਤੇ ਲੰਬੀਆਂ ਸਤਰਾਂ ਨੂੰ ਲਿਖਣਾ

ਸਟ੍ਰਿੰਗ ਵੇਰੀਏਬਲ ਲਈ ਇਹ ਲਿਖਣ ਦਾ ਤਰੀਕਾ ਸੰਭਵ ਨਹੀਂ ਹੈ।

# s = s1 s2 s3
# SyntaxError: invalid syntax

ਸੰਖਿਆਤਮਕ ਅਤੇ ਸਤਰ ਸੰਜੋਗ/ਕੰਕਟੇਨੇਸ਼ਨ:+,+=ਆਪਰੇਟਰ,str(),format(),f-ਸਤਰ

ਇੱਕ ਵੱਖਰੀ ਕਿਸਮ ਦੇ A + ਓਪਰੇਸ਼ਨ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਇੱਕ ਗਲਤੀ ਹੁੰਦੀ ਹੈ।

s1 = 'aaa'
s2 = 'bbb'

i = 100
f = 0.25

# s = s1 + i
# TypeError: must be str, not int

ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਸਟ੍ਰਿੰਗ ਨਾਲ ਇੱਕ ਸੰਖਿਆਤਮਕ ਮੁੱਲ (ਜਿਵੇਂ, ਪੂਰਨ ਅੰਕ ਕਿਸਮ ਇੰਟ ਜਾਂ ਫਲੋਟਿੰਗ-ਪੁਆਇੰਟ ਕਿਸਮ ਫਲੋਟ) ਨੂੰ ਜੋੜਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਸੰਖਿਆਤਮਕ ਮੁੱਲ ਨੂੰ str() ਨਾਲ ਇੱਕ ਸਟ੍ਰਿੰਗ ਕਿਸਮ ਵਿੱਚ ਬਦਲੋ ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ + ਆਪਰੇਟਰ (ਜਾਂ += ਆਪਰੇਟਰ) ਨਾਲ ਜੋੜੋ। ).

s = s1 + '_' + str(i) + '_' + s2 + '_' + str(f)
print(s)
# aaa_100_bbb_0.25

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

s = s1 + '_' + format(i, '05') + '_' + s2 + '_' + format(f, '.5f')
print(s)
# aaa_00100_bbb_0.25000

s = '{}_{:05}_{}_{:.5f}'.format(s1, i, s2, f)
print(s)
# aaa_00100_bbb_0.25000

ਬੇਸ਼ੱਕ, ਬਿਨਾਂ ਫਾਰਮੈਟ ਕੀਤੇ ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਇੱਕ ਵੇਰੀਏਬਲ ਦੇ ਮੁੱਲ ਨੂੰ ਏਮਬੈਡ ਕਰਨਾ ਵੀ ਸੰਭਵ ਹੈ। + ਆਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਨਾਲੋਂ ਇਹ ਲਿਖਣਾ ਸੌਖਾ ਹੈ।

s = '{}_{}_{}_{}'.format(s1, i, s2, f)
print(s)
# aaa_100_bbb_0.25

ਫਾਰਮੈਟ ਨੂੰ ਕਿਵੇਂ ਨਿਰਧਾਰਿਤ ਕਰਨਾ ਹੈ ਇਸ ਬਾਰੇ ਵੇਰਵਿਆਂ ਲਈ ਹੇਠਾਂ ਦਿੱਤਾ ਲੇਖ ਦੇਖੋ।

• ਸੰਬੰਧਿਤ ਲੇਖ:ਪਾਈਥਨ ਵਿੱਚ ਫਾਰਮੈਟ ਰੂਪਾਂਤਰਨ, ਫਾਰਮੈਟ (0-ਫਿਲਿੰਗ, ਘਾਤਕ ਸੰਕੇਤ, ਹੈਕਸਾਡੈਸੀਮਲ, ਆਦਿ)

ਪਾਈਥਨ 3.6 ਤੋਂ ਲੈ ਕੇ, f-ਸਟਰਿੰਗ (f-ਸਟ੍ਰਿੰਗ) ਨਾਮਕ ਇੱਕ ਵਿਧੀ ਵੀ ਪੇਸ਼ ਕੀਤੀ ਗਈ ਹੈ, ਜੋ ਕਿ ਫਾਰਮੈਟ() ਨਾਲੋਂ ਲਿਖਣ ਲਈ ਹੋਰ ਵੀ ਸਰਲ ਹੈ।

s = f'{s1}_{i:05}_{s2}_{f:.5f}'
print(s)
# aaa_00100_bbb_0.25000

s = f'{s1}_{i}_{s2}_{f}'
print(s)
# aaa_100_bbb_0.25

ਤਾਰਾਂ ਦੀਆਂ ਸੂਚੀਆਂ (ਐਰੇ) ਨੂੰ ਜੋੜੋ ਅਤੇ ਸ਼ਾਮਲ ਕਰੋ:join()

ਸਟਰਿੰਗ ਵਿਧੀ join() ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਸਤਰ ਵਿੱਚ ਸਟਰਿੰਗਾਂ ਦੀ ਸੂਚੀ ਨੂੰ ਜੋੜਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

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

ਹੇਠਾਂ ਇਸ ਨੂੰ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ.

'String to be inserted between'.join([List of strings to be concatenated])

ਇੱਕ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ ‘ਤੇ ‘ਸਟਰਿੰਗ ਟੂ ਇਨਸਰਟ ਬੀਚ’ ਦੇ ਨਾਲ join() ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰੋ ਅਤੇ [ਸਤਰਾਂ ਦੀ ਸੂਚੀ ਨੂੰ ਜੋੜੋ] ਪਾਸ ਕਰੋ।

ਜੇਕਰ ਇੱਕ ਖਾਲੀ ਸਤਰ ਵਰਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ [ਸੰਗਠਿਤ ਕੀਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ ਸਤਰਾਂ ਦੀ ਸੂਚੀ] ਨੂੰ ਸਿਰਫ਼ ਜੋੜਿਆ ਜਾਵੇਗਾ, ਜੇਕਰ ਇੱਕ ਕਾਮੇ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਸਤਰ ਕੌਮੇ ਨਾਲ ਵੱਖ ਕੀਤੀਆਂ ਜਾਣਗੀਆਂ, ਅਤੇ ਜੇਕਰ ਇੱਕ ਨਵੀਂ ਲਾਈਨ ਅੱਖਰ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਹਰੇਕ ਸਤਰ ਤੱਤ ਨੂੰ ਨਵੀਂ ਲਾਈਨ ਕੀਤਾ ਜਾਵੇਗਾ।

l = ['aaa', 'bbb', 'ccc']

s = ''.join(l)
print(s)
# aaabbbccc

s = ','.join(l)
print(s)
# aaa,bbb,ccc

s = '-'.join(l)
print(s)
# aaa-bbb-ccc

s = '\n'.join(l)
print(s)
# aaa
# bbb
# ccc

ਹਾਲਾਂਕਿ ਇੱਥੇ ਇੱਕ ਸੂਚੀ ਦੀ ਸਿਰਫ ਇੱਕ ਉਦਾਹਰਨ ਦਿੱਤੀ ਗਈ ਹੈ, ਹੋਰ ਦੁਹਰਾਉਣਯੋਗ ਆਬਜੈਕਟ ਜਿਵੇਂ ਕਿ ਟੂਪਲਸ ਨੂੰ ਵੀ ਜੋੜਨ ਲਈ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

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

ਸੰਖਿਆਵਾਂ ਦੀਆਂ ਸੂਚੀਆਂ (ਐਰੇ) ਨੂੰ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਜੋੜੋ ਅਤੇ ਜੋੜੋ:join(),str()

ਇੱਕ ਤਰੁੱਟੀ ਉਦੋਂ ਵਾਪਰਦੀ ਹੈ ਜੇਕਰ ਆਰਗੂਮੈਂਟ ਟੂ join() ਇੱਕ ਸੂਚੀ ਹੈ ਜਿਸ ਦੇ ਤੱਤ ਸਤਰ ਨਹੀਂ ਹਨ।

l = [0, 1, 2]

# s = '-'.join(l)
# TypeError: sequence item 0: expected str instance, int found

ਸੰਖਿਆਵਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਜੋੜਨ ਲਈ, ਨੰਬਰਾਂ ਨੂੰ ਇੱਕ ਸਤਰ ਵਿੱਚ ਬਦਲਣ ਲਈ ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਵਿੱਚ ਹਰੇਕ ਤੱਤ ਲਈ str() ਫੰਕਸ਼ਨ ਲਾਗੂ ਕਰੋ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ join() ਨਾਲ ਜੋੜੋ।

s = '-'.join([str(n) for n in l])
print(s)
# 0-1-2

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

s = '-'.join((str(n) for n in l))
print(s)
# 0-1-2

s = '-'.join(str(n) for n in l)
print(s)
# 0-1-2

ਜਨਰੇਟਰ ਸਮੀਕਰਨਾਂ ਦਾ ਆਮ ਤੌਰ ‘ਤੇ ਸੂਚੀ ਸਮਝਾਂ ਨਾਲੋਂ ਘੱਟ ਮੈਮੋਰੀ ਵਰਤਣ ਦਾ ਫਾਇਦਾ ਹੁੰਦਾ ਹੈ, ਪਰ ਜਨਰੇਟਰ ਸਮੀਕਰਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਕੋਈ ਖਾਸ ਫਾਇਦਾ ਨਹੀਂ ਹੈ ਕਿਉਂਕਿ join() ਜਨਰੇਟਰਾਂ ਨੂੰ ਇਸਦੀ ਅੰਦਰੂਨੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਸੂਚੀਆਂ ਵਿੱਚ ਬਦਲਦਾ ਹੈ। ਵਾਸਤਵ ਵਿੱਚ, ਸ਼ੁਰੂਆਤ ਤੋਂ ਸੂਚੀ ਦੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਥੋੜ੍ਹਾ ਤੇਜ਼ ਹੈ.

• python – List vs generator comprehension speed with join function – Stack Overflow

ਸੂਚੀ ਦੀ ਸਮਝ ਅਤੇ ਜਨਰੇਟਰ ਸਮੀਕਰਨਾਂ ਬਾਰੇ ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਲਈ, ਹੇਠਾਂ ਦਿੱਤਾ ਲੇਖ ਦੇਖੋ।

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