ਪਾਈਥਨ ਵਿੱਚ ਨਵੀਆਂ ਲਾਈਨਾਂ ਵਾਲੀਆਂ ਸਤਰਾਂ ਨੂੰ ਆਉਟਪੁੱਟ, ਜੋੜੋ, ਵੰਡੋ, ਮਿਟਾਓ ਅਤੇ ਬਦਲੋ

ਹੇਠਾਂ ਪਾਈਥਨ ਵਿੱਚ ਨਵੀਆਂ ਲਾਈਨਾਂ ਵਾਲੀਆਂ ਸਤਰਾਂ ਦੇ ਸੰਚਾਲਨ ਦਾ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ।

• ਨਵੀਂ ਲਾਈਨਾਂ, ਪ੍ਰਿੰਟ ਆਉਟਪੁੱਟ (ਡਿਸਪਲੇ) ਵਾਲੀ ਸਤਰ ਬਣਾਓ
  • ਨਵੀਂ ਲਾਈਨ ਅੱਖਰ (ਸਿਸਟਮ ‘ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ ਜਾਂ ਤਾਂ CR ਅਤੇ LF ਦੋਵੇਂ)\n(LF),\r\n(CR+LF)
  • ਤੀਹਰਾ ਹਵਾਲਾ'',"""
  • ਜੇਕਰ ਤੁਸੀਂ ਇੰਡੈਂਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ
• ਨਵੀਆਂ ਲਾਈਨਾਂ ਨਾਲ ਸਤਰ ਦੀ ਇੱਕ ਸੂਚੀ ਨੂੰ ਜੋੜੋ
• ਸਟ੍ਰਿੰਗ ਨੂੰ ਨਵੀਆਂ ਲਾਈਨਾਂ ਅਤੇ ਸੂਚੀ ਵਿੱਚ ਵੰਡੋ:splitlines()
• ਲਾਈਨ ਫੀਡ ਕੋਡ ਹਟਾਓ ਅਤੇ ਬਦਲੋ
• ਪ੍ਰਿੰਟ ਆਉਟਪੁੱਟ ਬਿਨਾਂ ਨਵੀਂ ਲਾਈਨ ਦੇ ਪਿੱਛੇ

ਨਵੀਂ ਲਾਈਨਾਂ, ਪ੍ਰਿੰਟ ਆਉਟਪੁੱਟ ਵਾਲੀ ਸਤਰ ਬਣਾਓ

ਨਵੀਂ ਲਾਈਨ ਅੱਖਰ (ਸਿਸਟਮ ‘ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ ਜਾਂ ਤਾਂ CR ਅਤੇ LF ਦੋਵੇਂ)\n(LF),\r\n(CR+LF)

ਇੱਕ ਸਤਰ ਦੇ ਅੰਦਰ ਇੱਕ ਲਾਈਨ ਫੀਡ ਕੋਡ ਪਾਉਣ ਨਾਲ ਇੱਕ ਨਵੀਂ ਲਾਈਨ ਆਵੇਗੀ।

s = 'Line1\nLine2\nLine3'
print(s)
# Line1
# Line2
# Line3

s = 'Line1\r\nLine2\r\nLine3'
print(s)
# Line1
# Line2
# Line3

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

ਤੀਹਰਾ ਹਵਾਲਾ'',"""

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

s = '''Line1
Line2
Line3'''
print(s)
# Line1
# Line2
# Line3

ਜੇਕਰ ਤੁਸੀਂ ਇੰਡੈਂਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ

ਟ੍ਰਿਪਲ ਕੋਟਸ ਇੱਕ ਸਤਰ ਵਿੱਚ ਸਪੇਸ ਵੀ ਹੁੰਦੇ ਹਨ, ਇਸਲਈ ਜੇਕਰ ਤੁਸੀਂ ਹੇਠਾਂ ਦਰਸਾਏ ਅਨੁਸਾਰ ਕੋਡ ਅਤੇ ਇੰਡੈਂਟ ਵਿੱਚ ਸਾਫ਼-ਸਾਫ਼ ਲਿਖਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ, ਤਾਂ ਬੇਲੋੜੀ ਸਪੇਸ ਪਾਈ ਜਾਵੇਗੀ।

s = '''
    Line1
    Line2
    Line3
    '''
print(s)
# 
#     Line1
#     Line2
#     Line3
#     

ਕੋਡ ਵਿੱਚ ਨਵੀਆਂ ਲਾਈਨਾਂ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਨਿਰੰਤਰਤਾ ਲਾਈਨ ਬਣਾਉਣ ਲਈ ਬੈਕਸਲੈਸ਼ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਇਸਨੂੰ ਹੇਠਾਂ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ

ਹਰੇਕ ਲਾਈਨ ਨੂੰ ” ਜਾਂ “” ਨਾਲ ਨੱਥੀ ਕਰੋ ਅਤੇ ਵਾਕ ਦੇ ਅੰਤ ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਲਾਈਨ ਅੱਖਰ ←n ਜੋੜੋ।

s = 'Line1\n'\
    'Line2\n'\
    'Line3'
print(s)
# Line1
# Line2
# Line3

ਇੱਥੇ, ਸੰਟੈਕਸ ਇਹ ਹੈ ਕਿ ਲਗਾਤਾਰ ਸਟ੍ਰਿੰਗ ਲਿਟਰਲ ਇਕੱਠੇ ਕੀਤੇ ਗਏ ਹਨ। ਵੇਰਵਿਆਂ ਲਈ ਅਗਲਾ ਲੇਖ ਦੇਖੋ।

• ਸੰਬੰਧਿਤ ਲੇਖ:ਪਾਈਥਨ (+ ਆਪਰੇਟਰ, ਜੁਆਇਨ, ਆਦਿ) ਵਿੱਚ ਤਾਰਾਂ ਨੂੰ ਜੋੜਨਾ ਅਤੇ ਜੋੜਨਾ

ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਸਤਰ ਵਿੱਚ ਇੰਡੈਂਟੇਸ਼ਨ ਜੋੜਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਹਰ ਲਾਈਨ ਵਿੱਚ ਸਤਰ ਵਿੱਚ ਇੱਕ ਸਪੇਸ ਜੋੜੋ।

s = 'Line1\n'\
    '    Line2\n'\
    '        Line3'
print(s)
# Line1
#     Line2
#         Line3

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਕਿਉਂਕਿ ਲਾਈਨ ਬਰੇਕਾਂ ਨੂੰ ਬਰੈਕਟਾਂ ਵਿੱਚ ਸੁਤੰਤਰ ਤੌਰ ‘ਤੇ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਇਸ ਲਈ ਬੈਕਸਲੈਸ਼ਾਂ ਦੀ ਬਜਾਏ ਬਰੈਕਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹੇਠਾਂ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ।

s = ('Line1\n'
     'Line2\n'
     'Line3')
print(s)
# Line1
# Line2
# Line3

s = ('Line1\n'
     '    Line2\n'
     '        Line3')
print(s)
# Line1
#     Line2
#         Line3

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

s = '''\
Line1
Line2
Line3'''
print(s)
# Line1
# Line2
# Line3

s = '''\
Line1
    Line2
        Line3'''
print(s)
# Line1
#     Line2
#         Line3

ਨਵੀਆਂ ਲਾਈਨਾਂ ਨਾਲ ਸਤਰ ਦੀ ਇੱਕ ਸੂਚੀ ਨੂੰ ਜੋੜੋ

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

• ਸੰਬੰਧਿਤ ਲੇਖ:ਪਾਈਥਨ (+ ਆਪਰੇਟਰ, ਜੁਆਇਨ, ਆਦਿ) ਵਿੱਚ ਤਾਰਾਂ ਨੂੰ ਜੋੜਨਾ ਅਤੇ ਜੋੜਨਾ

ਜਦੋਂ join() ਨੂੰ ਇੱਕ ਨਵੀਂ ਲਾਈਨ ਅੱਖਰ ਤੋਂ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਹਰੇਕ ਸਤਰ ਤੱਤ ਨੂੰ ਇੱਕ ਨਵੀਂ ਲਾਈਨ ਨਾਲ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ।

l = ['Line1', 'Line2', 'Line3']

s_n = '\n'.join(l)
print(s_n)
# Line1
# Line2
# Line3

print(repr(s_n))
# 'Line1\nLine2\nLine3'

s_rn = '\r\n'.join(l)
print(s_rn)
# Line1
# Line2
# Line3

print(repr(s_rn))
# 'Line1\r\nLine2\r\nLine3'

ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦਿੱਤੀ ਉਦਾਹਰਨ ਵਿੱਚ, ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ repr() ਦੀ ਵਰਤੋਂ ਉਹਨਾਂ ਸਤਰਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਜਿਹਨਾਂ ਵਿੱਚ ਨਵੇਂ ਲਾਈਨ ਕੋਡ ਹੁੰਦੇ ਹਨ ਜਿਵੇਂ ਕਿ ਉਹ ਹਨ।

• repr(object) — Built-in Functions — Python 3.10.2 Documentation

ਸਟ੍ਰਿੰਗ ਨੂੰ ਨਵੀਆਂ ਲਾਈਨਾਂ ਅਤੇ ਸੂਚੀ ਵਿੱਚ ਵੰਡੋ:splitlines()

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

splitlines() ਹੇਠਾਂ ਦਿੱਤੇ ਕਿਸੇ ਵੀ ਲਾਈਨ ਬ੍ਰੇਕ ਕੋਡ ਨੂੰ ਵੰਡ ਦੇਵੇਗਾ। ਵਰਟੀਕਲ ਟੈਬਸ ਅਤੇ ਪੇਜ ਬ੍ਰੇਕ ਵੀ ਵੰਡੇ ਗਏ ਹਨ।

• \n
• \r\n
• \v
• \f

s = 'Line1\nLine2\r\nLine3'
print(s.splitlines())
# ['Line1', 'Line2', 'Line3']

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

ਲਾਈਨ ਫੀਡ ਕੋਡ ਹਟਾਓ ਅਤੇ ਬਦਲੋ

ਸਪਲਿਟਲਾਈਨਾਂ() ਅਤੇ join() ਨੂੰ ਮਿਲਾ ਕੇ, ਨਵੀਂ ਲਾਈਨਾਂ ਵਾਲੀ ਸਟ੍ਰਿੰਗ ਤੋਂ ਨਵੇਂ ਲਾਈਨ ਕੋਡਾਂ ਨੂੰ ਹਟਾਉਣਾ (ਹਟਾਓ) ਜਾਂ ਉਹਨਾਂ ਨੂੰ ਹੋਰ ਸਤਰਾਂ ਨਾਲ ਬਦਲਣਾ ਸੰਭਵ ਹੈ।

s = 'Line1\nLine2\r\nLine3'

print(''.join(s.splitlines()))
# Line1Line2Line3

print(' '.join(s.splitlines()))
# Line1 Line2 Line3

print(','.join(s.splitlines()))
# Line1,Line2,Line3

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

s_n = '\n'.join(s.splitlines())
print(s_n)
# Line1
# Line2
# Line3

print(repr(s_n))
# 'Line1\nLine2\nLine3'

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

ਜੇਕਰ ਨਵੀਂ ਲਾਈਨ ਕੋਡ ਸਪਸ਼ਟ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਬਦਲੋ() ਵਿਧੀ ਨਾਲ ਵੀ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਜੋ ਸਟ੍ਰਿੰਗ ਨੂੰ ਬਦਲਦਾ ਹੈ।

s = 'Line1\nLine2\nLine3'

print(s.replace('\n', ''))
# Line1Line2Line3

print(s.replace('\n', ','))
# Line1,Line2,Line3

ਨੋਟ ਕਰੋ, ਹਾਲਾਂਕਿ, ਇਹ ਕੰਮ ਨਹੀਂ ਕਰੇਗਾ ਜੇਕਰ ਇਸ ਵਿੱਚ ਉਮੀਦ ਨਾਲੋਂ ਵੱਖਰੇ ਲਾਈਨ ਫੀਡ ਕੋਡ ਸ਼ਾਮਲ ਹਨ।

s = 'Line1\nLine2\r\nLine3'

s_error = s.replace('\n', ',')
print(s_error)
# ,Line3Line2

print(repr(s_error))
# 'Line1,Line2\r,Line3'

s_error = s.replace('\r\n', ',')
print(s_error)
# Line1
# Line2,Line3

print(repr(s_error))
# 'Line1\nLine2,Line3'

Replace() ਨੂੰ ਦੁਹਰਾ ਕੇ ਕਈ ਨਵੇਂ ਲਾਈਨ ਕੋਡਾਂ ਨੂੰ ਬਦਲਣਾ ਸੰਭਵ ਹੈ, ਪਰ ਜੇਕਰ ਆਰਡਰ ਗਲਤ ਹੈ ਤਾਂ ਇਹ ਕੰਮ ਨਹੀਂ ਕਰੇਗਾ ਕਿਉਂਕਿ “\r\n” ਵਿੱਚ “\n” ਸ਼ਾਮਲ ਹੈ। ਉੱਪਰ ਦੱਸੇ ਗਏ ਸਪਲਿਟਲਾਈਨਾਂ() ਅਤੇ join() ਨੂੰ ਜੋੜਨ ਵਾਲੀ ਵਿਧੀ ਵਧੇਰੇ ਸੁਰੱਖਿਅਤ ਹੈ ਕਿਉਂਕਿ ਲਾਈਨ ਫੀਡ ਕੋਡਾਂ ਬਾਰੇ ਚਿੰਤਾ ਕਰਨ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ।

s = 'Line1\nLine2\r\nLine3'

print(s.replace('\r\n', ',').replace('\n', ','))
# Line1,Line2,Line3

s_error = s.replace('\n', ',').replace('\r\n', ',')
print(s_error)
# ,Line3Line2

print(repr(s_error))
# 'Line1,Line2\r,Line3'

print(','.join(s.splitlines()))
# Line1,Line2,Line3

ਇੱਕ ਵਾਕ ਦੇ ਅੰਤ ਵਿੱਚ ਲਾਈਨ ਫੀਡ ਕੋਡਾਂ ਨੂੰ ਹਟਾਉਣ ਲਈ rstrip() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋ। rstrip() ਇੱਕ ਸਤਰ ਦੇ ਸੱਜੇ ਸਿਰੇ ‘ਤੇ ਚਿੱਟੇ ਸਪੇਸ ਅੱਖਰਾਂ (ਲਾਈਨ ਫੀਡਾਂ ਸਮੇਤ) ਨੂੰ ਹਟਾਉਣ ਦਾ ਇੱਕ ਤਰੀਕਾ ਹੈ।

s = 'aaa\n'
print(s + 'bbb')
# aaa
# bbb

print(s.rstrip() + 'bbb')
# aaabbb

ਪ੍ਰਿੰਟ ਆਉਟਪੁੱਟ ਬਿਨਾਂ ਨਵੀਂ ਲਾਈਨ ਦੇ ਪਿੱਛੇ

ਪ੍ਰਿੰਟ() ਫੰਕਸ਼ਨ ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ ਇੱਕ ਟ੍ਰੇਲਿੰਗ ਨਵੀਂ ਲਾਈਨ ਜੋੜਦਾ ਹੈ। ਇਸ ਲਈ, ਜੇਕਰ ਪ੍ਰਿੰਟ() ਨੂੰ ਲਗਾਤਾਰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਹਰੇਕ ਆਉਟਪੁੱਟ ਨਤੀਜਾ ਨਵੀਂ ਲਾਈਨ ‘ਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ।

print('a')
print('b')
print('c')
# a
# b
# c

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

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

print('a', end='')
print('b', end='')
print('c', end='')
# abc

ਆਰਗੂਮੈਂਟ ਦਾ ਅੰਤ ਕੋਈ ਵੀ ਸਤਰ ਹੋ ਸਕਦਾ ਹੈ।

print('a', end='-')
print('b', end='-')
print('c')
# a-b-c

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

• ਸੰਬੰਧਿਤ ਲੇਖ:ਪਾਈਥਨ (+ ਆਪਰੇਟਰ, ਜੁਆਇਨ, ਆਦਿ) ਵਿੱਚ ਤਾਰਾਂ ਨੂੰ ਜੋੜਨਾ ਅਤੇ ਜੋੜਨਾ