ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਲਾਈਨ ਵਿੱਚ ਟੈਕਸਟ ਦਾ ਅਨੁਵਾਦ। ਟੈਕਸਟ ਨੂੰ ਇੱਕ ਨਵੀਂ ਲਾਈਨ ਵਿੱਚ ਕਿਵੇਂ ਲਿਜਾਣਾ ਹੈ - ਨਿਰਦੇਸ਼

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

ਨਵੀਂ ਲਾਈਨ ਅੱਖਰ ਬਾਰੇ ਆਮ ਜਾਣਕਾਰੀ

n ਇੱਕ ਨਵੀਂ ਲਾਈਨ ਉੱਤੇ ਜਾਣਕਾਰੀ ਨੂੰ ਸਮੇਟਣ ਅਤੇ ਪਾਈਥਨ ਵਿੱਚ ਪੁਰਾਣੀ ਲਾਈਨ ਨੂੰ ਬੰਦ ਕਰਨ ਦਾ ਪ੍ਰਤੀਕ ਹੈ। ਇਸ ਚਿੰਨ੍ਹ ਵਿੱਚ ਦੋ ਤੱਤ ਸ਼ਾਮਲ ਹਨ:

  • ਉਲਟਾ ਤਿਰਛਾ;
  • n ਇੱਕ ਛੋਟਾ ਅੱਖਰ ਹੈ।

ਇਸ ਅੱਖਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਸਮੀਕਰਨ “print(f” HellonWorld!”) ” ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਜਿਸ ਕਾਰਨ ਤੁਸੀਂ f-ਲਾਈਨਾਂ ਵਿੱਚ ਜਾਣਕਾਰੀ ਟ੍ਰਾਂਸਫਰ ਕਰ ਸਕਦੇ ਹੋ।

ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਲਾਈਨ ਵਿੱਚ ਟੈਕਸਟ ਦਾ ਅਨੁਵਾਦ। ਟੈਕਸਟ ਨੂੰ ਇੱਕ ਨਵੀਂ ਲਾਈਨ ਵਿੱਚ ਕਿਵੇਂ ਲਿਜਾਣਾ ਹੈ - ਨਿਰਦੇਸ਼
ਨਵੀਆਂ ਲਾਈਨਾਂ ਉੱਤੇ ਜਾਣਕਾਰੀ ਦੀ ਇੱਕ ਲੜੀ ਨੂੰ ਵੰਡਣ ਲਈ ਅੱਖਰ n ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਨ

ਪ੍ਰਿੰਟ ਫੰਕਸ਼ਨ ਕੀ ਹੈ

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

ਪ੍ਰਿੰਟ (“ਹੈਲੋ, ਵਰਲਡ”!”) – “ਹੈਲੋ, ਵਰਲਡ!”n

ਇਸ ਦੇ ਨਾਲ ਹੀ, ਇਸ ਪਾਤਰ ਦੀ ਅਜਿਹੀ ਖੋਜ ਪਾਈਥਨ ਦੀਆਂ ਬੁਨਿਆਦੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਲਿਖੀ ਗਈ ਹੈ। "ਪ੍ਰਿੰਟ" ਫੰਕਸ਼ਨ ਦਾ "ਅੰਤ" ਪੈਰਾਮੀਟਰ ਲਈ ਇੱਕ ਡਿਫੌਲਟ ਮੁੱਲ ਹੈ - n. ਇਹ ਇਸ ਫੰਕਸ਼ਨ ਦਾ ਧੰਨਵਾਦ ਹੈ ਕਿ ਇਹ ਅੱਖਰ ਅਗਲੀਆਂ ਲਾਈਨਾਂ ਵਿੱਚ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਲਈ ਲਾਈਨਾਂ ਦੇ ਅੰਤ ਵਿੱਚ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ। "ਪ੍ਰਿੰਟ" ਫੰਕਸ਼ਨ ਦੀ ਵਿਆਖਿਆ:

ਪ੍ਰਿੰਟ (*ਆਬਜੈਕਟ, sep=' ', end='n', file=sys.stdout, flush=False)

"ਪ੍ਰਿੰਟ" ਫੰਕਸ਼ਨ ਤੋਂ "ਐਂਡ" ਪੈਰਾਮੀਟਰ ਦਾ ਮੁੱਲ ਅੱਖਰ "n" ਦੇ ਬਰਾਬਰ ਹੈ। ਪ੍ਰੋਗਰਾਮ ਕੋਡ ਦੇ ਆਟੋਮੈਟਿਕ ਐਲਗੋਰਿਦਮ ਦੇ ਅਨੁਸਾਰ, ਇਹ ਅੰਤ ਵਿੱਚ ਲਾਈਨਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ, ਜਿਸ ਤੋਂ ਪਹਿਲਾਂ "ਪ੍ਰਿੰਟ" ਫੰਕਸ਼ਨ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਸਿੰਗਲ "ਪ੍ਰਿੰਟ" ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਤੁਸੀਂ ਇਸਦੇ ਕੰਮ ਦੇ ਸਾਰ ਨੂੰ ਨਹੀਂ ਦੇਖ ਸਕਦੇ ਹੋ, ਕਿਉਂਕਿ ਸਕ੍ਰੀਨ 'ਤੇ ਸਿਰਫ ਇੱਕ ਲਾਈਨ ਪ੍ਰਦਰਸ਼ਿਤ ਹੋਵੇਗੀ. ਹਾਲਾਂਕਿ, ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਕੁਝ ਕਥਨਾਂ ਨੂੰ ਜੋੜਦੇ ਹੋ, ਤਾਂ ਫੰਕਸ਼ਨ ਦਾ ਨਤੀਜਾ ਵਧੇਰੇ ਸਪੱਸ਼ਟ ਹੋ ਜਾਂਦਾ ਹੈ:

ਪ੍ਰਿੰਟ ("ਹੈਲੋ, ਵਰਲਡ 1!") ਪ੍ਰਿੰਟ ("ਹੈਲੋ, ਵਰਲਡ 2!") ਪ੍ਰਿੰਟ ("ਹੈਲੋ, ਵਰਲਡ 3!") ਪ੍ਰਿੰਟ ("ਹੈਲੋ, ਵਰਲਡ 4!")

ਉਪਰੋਕਤ ਕੋਡ ਦੇ ਨਤੀਜੇ ਦੀ ਇੱਕ ਉਦਾਹਰਨ:

ਹੈਲੋ, ਵਰਲਡ 1! ਹੈਲੋ, ਵਰਲਡ 2! ਹੈਲੋ, ਵਰਲਡ 3! ਹੈਲੋ, ਵਰਲਡ 4!

ਇੱਕ ਨਵੀਂ ਲਾਈਨ ਅੱਖਰ ਨੂੰ ਪ੍ਰਿੰਟ ਨਾਲ ਬਦਲਣਾ

"ਪ੍ਰਿੰਟ" ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਲਾਈਨਾਂ ਵਿਚਕਾਰ ਵਿਭਾਜਕ ਅੱਖਰ ਦੀ ਵਰਤੋਂ ਨਾ ਕਰਨਾ ਸੰਭਵ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਫੰਕਸ਼ਨ ਵਿੱਚ ਹੀ "ਅੰਤ" ਪੈਰਾਮੀਟਰ ਨੂੰ ਬਦਲਣ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, "ਅੰਤ" ਮੁੱਲ ਦੀ ਬਜਾਏ, ਤੁਹਾਨੂੰ ਇੱਕ ਸਪੇਸ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ। ਇਸਦੇ ਕਾਰਨ, ਇਹ ਉਹ ਥਾਂ ਹੈ ਜੋ "ਅੰਤ" ਅੱਖਰ ਨੂੰ ਬਦਲ ਦੇਵੇਗੀ। ਪੂਰਵ-ਨਿਰਧਾਰਤ ਸੈਟਿੰਗਾਂ ਦੇ ਨਾਲ ਨਤੀਜਾ:

>>> ਪ੍ਰਿੰਟ("ਹੈਲੋ") >>> ਪ੍ਰਿੰਟ("ਵਰਲਡ") ਹੈਲੋ ਵਰਲਡ

ਅੱਖਰ “n” ਨੂੰ ਸਪੇਸ ਨਾਲ ਬਦਲਣ ਤੋਂ ਬਾਅਦ ਨਤੀਜਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ:

>>> print("Hello", end=" ") >>> print("World") ਹੈਲੋ ਵਰਲਡ

ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਮੁੱਲਾਂ ਦੇ ਕ੍ਰਮ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਅੱਖਰਾਂ ਨੂੰ ਬਦਲਣ ਦੀ ਇਸ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਣ:

ਰੇਂਜ ਵਿੱਚ i ਲਈ (15): ਜੇਕਰ i <14: print(i, end=", ") else: print(i)

ਫਾਈਲਾਂ ਵਿੱਚ ਵਿਭਾਜਕ ਅੱਖਰ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਪ੍ਰਤੀਕ ਜਿਸ ਤੋਂ ਬਾਅਦ ਪ੍ਰੋਗਰਾਮ ਕੋਡ ਦਾ ਟੈਕਸਟ ਅਗਲੀ ਲਾਈਨ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਮੁਕੰਮਲ ਫਾਈਲਾਂ ਵਿੱਚ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਪ੍ਰੋਗ੍ਰਾਮ ਕੋਡ ਦੁਆਰਾ ਦਸਤਾਵੇਜ਼ ਨੂੰ ਦੇਖਣ ਤੋਂ ਬਿਨਾਂ, ਇਸਨੂੰ ਦੇਖਣਾ ਅਸੰਭਵ ਹੈ, ਕਿਉਂਕਿ ਅਜਿਹੇ ਅੱਖਰ ਮੂਲ ਰੂਪ ਵਿੱਚ ਲੁਕੇ ਹੋਏ ਹਨ. ਨਵੀਂ ਲਾਈਨ ਅੱਖਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਨਾਵਾਂ ਨਾਲ ਭਰੀ ਇੱਕ ਫਾਈਲ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ। ਇਸਨੂੰ ਖੋਲ੍ਹਣ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਸਾਰੇ ਨਾਮ ਇੱਕ ਨਵੀਂ ਲਾਈਨ 'ਤੇ ਸ਼ੁਰੂ ਹੋਣਗੇ। ਉਦਾਹਰਨ:

names = ['Petr', 'Dima', 'Artem', 'Ivan'] open("names.txt", "w") ਦੇ ਨਾਲ f: ਨਾਮਾਂ ਵਿੱਚ ਨਾਮ ਲਈ[:-1]: f.write(f) "{name}n") f.write(names[-1])

ਨਾਂ ਇਸ ਤਰੀਕੇ ਨਾਲ ਹੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੇ ਜਾਣਗੇ ਜੇਕਰ ਟੈਕਸਟ ਫਾਈਲ ਨੂੰ ਵੱਖਰੀਆਂ ਲਾਈਨਾਂ ਵਿੱਚ ਵੱਖਰੀ ਜਾਣਕਾਰੀ ਲਈ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਹ ਹਰ ਪਿਛਲੀ ਲਾਈਨ ਦੇ ਅੰਤ ਵਿੱਚ ਆਪਣੇ ਆਪ ਲੁਕਵੇਂ ਅੱਖਰ "n" ਨੂੰ ਸੈੱਟ ਕਰੇਗਾ। ਲੁਕਵੇਂ ਚਿੰਨ੍ਹ ਨੂੰ ਦੇਖਣ ਲਈ, ਤੁਹਾਨੂੰ ਫੰਕਸ਼ਨ ਨੂੰ ਸਰਗਰਮ ਕਰਨ ਦੀ ਲੋੜ ਹੈ – “.readlines()”। ਉਸ ਤੋਂ ਬਾਅਦ, ਪ੍ਰੋਗਰਾਮ ਕੋਡ ਵਿੱਚ ਸਾਰੇ ਲੁਕਵੇਂ ਅੱਖਰ ਸਕ੍ਰੀਨ ਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਹੋਣਗੇ. ਫੰਕਸ਼ਨ ਐਕਟੀਵੇਸ਼ਨ ਉਦਾਹਰਨ:

f: print(f.readlines()) ਦੇ ਰੂਪ ਵਿੱਚ open("names.txt", "r") ਦੇ ਨਾਲ
ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਲਾਈਨ ਵਿੱਚ ਟੈਕਸਟ ਦਾ ਅਨੁਵਾਦ। ਟੈਕਸਟ ਨੂੰ ਇੱਕ ਨਵੀਂ ਲਾਈਨ ਵਿੱਚ ਕਿਵੇਂ ਲਿਜਾਣਾ ਹੈ - ਨਿਰਦੇਸ਼
ਪਾਈਥਨ ਵਿੱਚ ਕੰਮ ਕਰਨ ਲਈ ਵੱਖ-ਵੱਖ ਚਿੰਨ੍ਹ ਨਿਰਧਾਰਤ ਕਰਨਾ

ਸਲਾਹ! ਪਾਈਥਨ ਦੇ ਨਾਲ ਸਰਗਰਮੀ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋਏ, ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਅਕਸਰ ਅਜਿਹੀਆਂ ਸਥਿਤੀਆਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈਂਦਾ ਹੈ ਜਿੱਥੇ ਪ੍ਰੋਗਰਾਮ ਕੋਡ ਨੂੰ ਇੱਕ ਲੰਬੀ ਲਾਈਨ ਵਿੱਚ ਲਿਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਪਰ ਇਸਦੀ ਸਮੀਖਿਆ ਕਰਨਾ ਅਤੇ ਵੱਖ ਕੀਤੇ ਬਿਨਾਂ ਗਲਤੀਆਂ ਦੀ ਪਛਾਣ ਕਰਨਾ ਬਹੁਤ ਮੁਸ਼ਕਲ ਹੈ। ਇਸ ਲਈ ਕਿ ਇੱਕ ਲੰਬੀ ਲਾਈਨ ਨੂੰ ਵੱਖਰੇ ਟੁਕੜਿਆਂ ਵਿੱਚ ਵੰਡਣ ਤੋਂ ਬਾਅਦ, ਕੰਪਿਊਟਰ ਇਸਨੂੰ ਪੂਰਾ ਸਮਝਦਾ ਹੈ, ਮੁੱਲਾਂ ਦੇ ਵਿਚਕਾਰ ਹਰੇਕ ਖਾਲੀ ਪਾੜੇ ਵਿੱਚ, ਤੁਹਾਨੂੰ ਅੱਖਰ “” - ਇੱਕ ਬੈਕਸਲੈਸ਼ ਪਾਉਣਾ ਚਾਹੀਦਾ ਹੈ। ਇੱਕ ਅੱਖਰ ਜੋੜਨ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਕਿਸੇ ਹੋਰ ਲਾਈਨ ਵਿੱਚ ਜਾ ਸਕਦੇ ਹੋ, ਕੋਡ ਲਿਖਣਾ ਜਾਰੀ ਰੱਖ ਸਕਦੇ ਹੋ। ਲਾਂਚ ਦੇ ਦੌਰਾਨ, ਪ੍ਰੋਗਰਾਮ ਖੁਦ ਵਿਅਕਤੀਗਤ ਟੁਕੜਿਆਂ ਨੂੰ ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਇਕੱਠਾ ਕਰੇਗਾ।

ਇੱਕ ਸਟ੍ਰਿੰਗ ਨੂੰ ਸਬਸਟਰਿੰਗਾਂ ਵਿੱਚ ਵੰਡਣਾ

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

string = "ਕੁਝ ਨਵਾਂ ਟੈਕਸਟ" ਸਤਰ = string.split() print(strings) ['some', 'new', 'text']

ਰਿਵਰਸ ਪਰਿਵਰਤਨ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ, ਜਿਸ ਦੀ ਮਦਦ ਨਾਲ ਸਬਸਟਰਿੰਗਾਂ ਦੀ ਸੂਚੀ ਇੱਕ ਲੰਬੀ ਸਤਰ ਵਿੱਚ ਬਦਲ ਜਾਵੇਗੀ, ਤੁਹਾਨੂੰ ਜੋੜਨ ਦੀ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ। ਸਤਰ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਇੱਕ ਹੋਰ ਲਾਭਦਾਇਕ ਤਰੀਕਾ ਹੈ ਸਟ੍ਰਿਪ. ਇਸਦੇ ਨਾਲ, ਤੁਸੀਂ ਲਾਈਨ ਦੇ ਦੋਵੇਂ ਪਾਸੇ ਸਥਿਤ ਖਾਲੀ ਥਾਂਵਾਂ ਨੂੰ ਹਟਾ ਸਕਦੇ ਹੋ।

ਸਿੱਟਾ

ਪਾਈਥਨ ਵਿੱਚ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਇੱਕ ਨਵੀਂ ਲਾਈਨ ਤੋਂ ਕੁਝ ਡੇਟਾ ਨੂੰ ਆਉਟਪੁੱਟ ਕਰਨ ਲਈ, ਪੁਰਾਣੀ ਲਾਈਨ ਨੂੰ "n" ਅੱਖਰ ਨਾਲ ਖਤਮ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ। ਇਸਦੀ ਮਦਦ ਨਾਲ, ਚਿੰਨ੍ਹ ਤੋਂ ਬਾਅਦ ਦੀ ਜਾਣਕਾਰੀ ਅਗਲੀ ਲਾਈਨ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਪੁਰਾਣੀ ਨੂੰ ਬੰਦ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ. ਹਾਲਾਂਕਿ, ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਲਈ ਇਸ ਚਿੰਨ੍ਹ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਜ਼ਰੂਰੀ ਨਹੀਂ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਪੈਰਾਮੀਟਰ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ end = ""। ਮੁੱਲ "ਅੱਖਰ" ਵੱਖ ਕਰਨ ਵਾਲਾ ਅੱਖਰ ਹੈ।

ਕੋਈ ਜਵਾਬ ਛੱਡਣਾ