ਸਮੱਗਰੀ
ਪ੍ਰਿੰਟ() - ਸੰਭਵ ਤੌਰ 'ਤੇ ਸਭ ਤੋਂ ਪਹਿਲੀ ਕਮਾਂਡ ਜੋ ਸ਼ੁਰੂਆਤੀ ਤੌਰ 'ਤੇ ਪਾਈਥਨ ਨੂੰ ਸਕ੍ਰੈਚ ਤੋਂ ਸਿੱਖਣ ਵੇਲੇ ਮਿਲਦੀ ਹੈ। ਲਗਭਗ ਹਰ ਕੋਈ ਸਕਰੀਨ 'ਤੇ ਇੱਕ ਸਧਾਰਨ ਸ਼ੁਭਕਾਮਨਾਵਾਂ ਨਾਲ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ ਅਤੇ ਵਾਧੂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਬਾਰੇ ਸੋਚੇ ਬਿਨਾਂ, ਸੰਟੈਕਸ, ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਭਾਸ਼ਾ ਦੇ ਤਰੀਕਿਆਂ ਦੇ ਹੋਰ ਅਧਿਐਨ ਵੱਲ ਵਧਦਾ ਹੈ। ਛਾਪੋ (). ਹਾਲਾਂਕਿ, Pyt ਵਿੱਚh3 'ਤੇ ਇਹ ਕਮਾਂਡ ਬੁਨਿਆਦੀ ਡਾਟਾ ਆਉਟਪੁੱਟ ਫੰਕਸ਼ਨ ਨੂੰ ਇਸਦੇ ਅੰਦਰੂਨੀ ਪੈਰਾਮੀਟਰਾਂ ਅਤੇ ਸਮਰੱਥਾਵਾਂ ਨਾਲ ਪਹੁੰਚ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ। ਇਹਨਾਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਜਾਣਨਾ ਤੁਹਾਨੂੰ ਹਰੇਕ ਖਾਸ ਕੇਸ ਲਈ ਡੇਟਾ ਦੇ ਆਉਟਪੁੱਟ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਦੀ ਆਗਿਆ ਦੇਵੇਗਾ।
ਵਿਸ਼ੇਸ਼ਤਾ ਲਾਭ ਪ੍ਰਿੰਟ() ਵਿਚ ਪਾਈਥਨ 3
Pyt ਦੇ ਤੀਜੇ ਸੰਸਕਰਣ ਵਿੱਚhon ਪ੍ਰਿੰਟ() ਫੰਕਸ਼ਨਾਂ ਦੇ ਮੁਢਲੇ ਸਮੂਹ ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ। ਜਾਂਚ ਕਰਦੇ ਸਮੇਂ ਦੀ ਕਿਸਮ(ਪ੍ਰਿੰਟ) ਜਾਣਕਾਰੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੀ ਗਈ ਹੈ: ਕਲਾਸ 'ਬਿਲਟਿਨ_ਫੰਕਸ਼ਨ_or_ਢੰਗ ਹੈ'. ਸ਼ਬਦ ਬਿਲਟਿਨ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਟੈਸਟ ਕੀਤਾ ਜਾ ਰਿਹਾ ਫੰਕਸ਼ਨ ਇਨਲਾਈਨ ਹੈ।
ਕੋਈ ਗੱਲ ਨਹੀਂh3 ਆਉਟਪੁੱਟ ਵਸਤੂਆਂ 'ਤੇ (ਆਬਜੈਕਟs) ਸ਼ਬਦ ਦੇ ਬਾਅਦ ਬਰੈਕਟਾਂ ਵਿੱਚ ਰੱਖੇ ਗਏ ਹਨ ਪ੍ਰਿੰਟ. ਪਰੰਪਰਾਗਤ ਨਮਸਕਾਰ ਦੇ ਆਉਟਪੁੱਟ ਦੀ ਉਦਾਹਰਨ 'ਤੇ, ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ:
ਲਈ ਪਾਈਥਨ 3: ਪ੍ਰਿੰਟ ('ਹੈਲੋ, ਵਰਲਡ!').
ਪਾਈਥਨ 2 ਵਿੱਚ, ਬਿਆਨ ਨੂੰ ਬਰੈਕਟਾਂ ਤੋਂ ਬਿਨਾਂ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ: ਪ੍ਰਿੰਟ 'ਸਤ ਸ੍ਰੀ ਅਕਾਲ, ਵਿਸ਼ਵ! '
ਦੋਵਾਂ ਸੰਸਕਰਣਾਂ ਵਿੱਚ ਨਤੀਜਾ ਇੱਕੋ ਜਿਹਾ ਹੋਵੇਗਾ: ਸਤ ਸ੍ਰੀ ਅਕਾਲ, ਵਿਸ਼ਵ!
ਜੇਕਰ ਪਾਈਥਨ ਦੇ ਦੂਜੇ ਸੰਸਕਰਣ ਵਿੱਚ ਇਸਦੇ ਬਾਅਦ ਦੇ ਮੁੱਲ ਪ੍ਰਿੰਟ ਬਰੈਕਟਾਂ ਵਿੱਚ ਪਾਓ, ਫਿਰ ਇੱਕ ਟੂਪਲ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ - ਇੱਕ ਡੇਟਾ ਕਿਸਮ ਜੋ ਇੱਕ ਅਟੱਲ ਸੂਚੀ ਹੈ:
ਪ੍ਰਿੰਟ (1, 'ਪਹਿਲਾ', 2, 'ਦੂਜਾ')
(1, 'ਪਹਿਲਾ', 2, 'ਦੂਜਾ')
ਜਦੋਂ ਬਾਅਦ ਬਰੈਕਟਾਂ ਨੂੰ ਹਟਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ ਪ੍ਰਿੰਟ ਪਾਈਥਨ ਦੇ ਤੀਜੇ ਸੰਸਕਰਣ ਵਿੱਚ, ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਸਿੰਟੈਕਸ ਗਲਤੀ ਦੇਵੇਗਾ।
ਪ੍ਰਿੰਟ ("ਹੈਲੋ, ਵਰਲਡ!")ਫਾਈਲ"", ਲਾਈਨ 1 ਪ੍ਰਿੰਟ "ਹੈਲੋ, ਵਰਲਡ!" ^ ਸਿੰਟੈਕਸ ਐਰਰ: 'ਪ੍ਰਿੰਟ' ਲਈ ਕਾਲ ਵਿੱਚ ਬਰੈਕਟ ਗੁੰਮ ਹਨ। ਕੀ ਤੁਹਾਡਾ ਮਤਲਬ ਪ੍ਰਿੰਟ ("ਹੈਲੋ, ਵਰਲਡ!") ਸੀ?
ਪਾਈਥਨ 3 ਵਿੱਚ ਪ੍ਰਿੰਟ() ਸੰਟੈਕਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ
ਫੰਕਸ਼ਨ ਸਿੰਟੈਕਸ ਛਾਪੋ () ਅਸਲ ਵਸਤੂ ਜਾਂ ਵਸਤੂਆਂ (ਆਬਜੈਕਟ), ਜਿਸ ਨੂੰ ਮੁੱਲ ਵੀ ਕਿਹਾ ਜਾ ਸਕਦਾ ਹੈ (ਮੁੱਲ) ਜਾਂ ਤੱਤ (ਇਕਾਈ), ਅਤੇ ਕੁਝ ਵਿਕਲਪ। ਵਸਤੂਆਂ ਨੂੰ ਕਿਵੇਂ ਰੈਂਡਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਇਹ ਚਾਰ ਨਾਮਿਤ ਆਰਗੂਮੈਂਟਾਂ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ: ਤੱਤ ਵੱਖ ਕਰਨ ਵਾਲਾ (ਸਤੰਬਰ), ਸਾਰੀਆਂ ਵਸਤੂਆਂ ਦੇ ਬਾਅਦ ਛਾਪੀ ਗਈ ਇੱਕ ਸਤਰ (ਅੰਤ), ਫਾਈਲ ਜਿੱਥੇ ਡੇਟਾ ਆਉਟਪੁੱਟ ਹੁੰਦਾ ਹੈ (ਭਰੀ), ਅਤੇ ਆਉਟਪੁੱਟ ਬਫਰਿੰਗ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਪੈਰਾਮੀਟਰ (ਫਲੱਸ਼).
ਪ੍ਰਿੰਟ(ਮੁੱਲ, ..., sep='', end='n', file=sys.stdout, flush=False)
ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਪੈਰਾਮੀਟਰ ਮੁੱਲਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤੇ ਬਿਨਾਂ ਅਤੇ ਬਿਨਾਂ ਕਿਸੇ ਵਸਤੂ ਦੇ ਵੀ ਸੰਭਵ ਹੈ: ਛਾਪੋ (). ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਡਿਫੌਲਟ ਪੈਰਾਮੀਟਰ ਵਰਤੇ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਜੇਕਰ ਕੋਈ ਤੱਤ ਨਹੀਂ ਹਨ, ਤਾਂ ਇੱਕ ਅਣਡਿਸਪਲੇਡ ਖਾਲੀ ਸਤਰ ਅੱਖਰ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ - ਅਸਲ ਵਿੱਚ, ਪੈਰਾਮੀਟਰ ਦਾ ਮੁੱਲ ਅੰਤ - 'n'. ਅਜਿਹੀ ਕਾਲ, ਉਦਾਹਰਨ ਲਈ, ਪਿੰਨ ਦੇ ਵਿਚਕਾਰ ਵਰਟੀਕਲ ਇੰਡੈਂਟੇਸ਼ਨ ਲਈ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ।
ਸਾਰੇ ਗੈਰ-ਕੀਵਰਡ ਆਰਗੂਮੈਂਟਸ (ਆਬਜੈਕਟ) ਨੂੰ ਡੇਟਾ ਸਟ੍ਰੀਮ ਵਿੱਚ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ, ਦੁਆਰਾ ਵੱਖ ਕੀਤੀਆਂ ਸਤਰਾਂ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ ਸਤੰਬਰ ਅਤੇ ਪੂਰਾ ਕੀਤਾ ਅੰਤ. ਪੈਰਾਮੀਟਰ ਆਰਗੂਮੈਂਟਸ ਸਤੰਬਰ и ਅੰਤ ਇੱਕ ਸਟ੍ਰਿੰਗ ਕਿਸਮ ਵੀ ਹੈ, ਡਿਫੌਲਟ ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਉਹਨਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
ਪੈਰਾਮੀਟਰ ਸਤੰਬਰ
ਸਾਰੇ ਮਾਪਦੰਡਾਂ ਦੇ ਮੁੱਲ ਪ੍ਰਿੰਟ ਕੀਵਰਡ ਆਰਗੂਮੈਂਟਸ ਦੇ ਰੂਪ ਵਿੱਚ ਵਰਣਿਤ ਹਨ ਸਤੰਬਰ, ਅੰਤ, ਭਰੀ, ਫਲੱਸ਼. ਜੇਕਰ ਪੈਰਾਮੀਟਰ ਸਤੰਬਰ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਫਿਰ ਇਸਦਾ ਮੂਲ ਮੁੱਲ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ: ਸਤੰਬਰ=”, ਅਤੇ ਆਉਟਪੁੱਟ ਵਸਤੂਆਂ ਨੂੰ ਸਪੇਸ ਦੁਆਰਾ ਵੱਖ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ:
ਪ੍ਰਿੰਟ(1, 2, 3)
1 2 3
ਇੱਕ ਦਲੀਲ ਦੇ ਤੌਰ ਤੇ ਸਤੰਬਰ ਤੁਸੀਂ ਕੋਈ ਹੋਰ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ, ਉਦਾਹਰਨ ਲਈ:
- ਵੱਖ ਕਰਨ ਵਾਲਾ ਗੁੰਮ ਹੈ sep=»;
- ਨਵੀਂ ਲਾਈਨ ਆਉਟਪੁੱਟ sep ='ਨਹੀਂ ';
- ਜਾਂ ਕੋਈ ਲਾਈਨ:
ਪ੍ਰਿੰਟ(1, 2, 3, sep='ਵੱਖ ਕਰਨ ਵਾਲਾ ਸ਼ਬਦ')
1 ਸ਼ਬਦ-ਵਿਭਾਜਕ 2 ਸ਼ਬਦ-ਵੱਖ ਕਰਨ ਵਾਲਾ 3
ਪੈਰਾਮੀਟਰ ਅੰਤ
ਮੂਲ ਰੂਪ ਵਿੱਚ ਅੰਤ='n', ਅਤੇ ਵਸਤੂਆਂ ਦਾ ਆਉਟਪੁੱਟ ਇੱਕ ਨਵੀਂ ਲਾਈਨ ਨਾਲ ਖਤਮ ਹੁੰਦਾ ਹੈ। ਡਿਫਾਲਟ ਮੁੱਲ ਨੂੰ ਕਿਸੇ ਹੋਰ ਆਰਗੂਮੈਂਟ ਨਾਲ ਬਦਲਣਾ, ਉਦਾਹਰਨ ਲਈ, ਅੰਤ= ", ਆਉਟਪੁੱਟ ਡੇਟਾ ਦੇ ਫਾਰਮੈਟ ਨੂੰ ਬਦਲ ਦੇਵੇਗਾ:
ਛਾਪੋ('one_', end=»)
ਪ੍ਰਿੰਟ ('ਦੋ_', ਅੰਤ =»)
ਛਾਪੋ ('ਤਿੰਨ')
ਇੱਕ ਦੋ ਤਿੰਨ
ਪੈਰਾਮੀਟਰ ਭਰੀ
ਕਾਰਜਾਤਮਕ ਛਾਪੋ () ਪੈਰਾਮੀਟਰ ਦੁਆਰਾ ਆਉਟਪੁੱਟ ਰੀਡਾਇਰੈਕਸ਼ਨ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ ਭਰੀ, ਜਿਸਦਾ ਮੂਲ ਰੂਪ ਵਿੱਚ ਹਵਾਲਾ ਦਿੰਦਾ ਹੈ sys.stdout - ਮਿਆਰੀ ਆਉਟਪੁੱਟ. ਮੁੱਲ ਵਿੱਚ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ sys.stdin or sys.stderr. ਫਾਈਲ ਆਬਜੈਕਟ stdin ਇੰਪੁੱਟ 'ਤੇ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ stderr ਦੁਭਾਸ਼ੀਏ ਦੇ ਸੰਕੇਤ ਅਤੇ ਗਲਤੀ ਸੁਨੇਹੇ ਭੇਜਣ ਲਈ। ਪੈਰਾਮੀਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਭਰੀ ਤੁਸੀਂ ਆਉਟਪੁੱਟ ਨੂੰ ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਸੈੱਟ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ .csv ਜਾਂ .txt ਫ਼ਾਈਲਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਇੱਕ ਸਤਰ ਲਿਖਣ ਦਾ ਸੰਭਵ ਤਰੀਕਾ:
fileitem = ਖੋਲ੍ਹੋ ('printfile.txt', 'a')
def ਟੈਸਟ (ਆਬਜੈਕਟਸ):
ਵਸਤੂਆਂ ਵਿੱਚ ਤੱਤ ਲਈ:
ਪ੍ਰਿੰਟ (ਤੱਤ, ਫਾਈਲ = ਫਾਈਲ ਆਈਟਮ)
fileitem.close()
ਟੈਸਟ([10,9,8,7,6,5,4,3,2,1])
ਆਉਟਪੁੱਟ 'ਤੇ, ਸੂਚੀ ਦੇ ਤੱਤਾਂ ਨੂੰ ਲਿਖਿਆ ਜਾਵੇਗਾ ਪ੍ਰਿੰਟ ਫਾਈਲ.txt ਪ੍ਰਤੀ ਲਾਈਨ ਇੱਕ.
ਪੈਰਾਮੀਟਰ ਫਲੱਸ਼
ਇਹ ਪੈਰਾਮੀਟਰ ਡਾਟਾ ਸਟ੍ਰੀਮ ਬਫਰਿੰਗ ਨਾਲ ਕਰਨਾ ਹੈ ਅਤੇ ਕਿਉਂਕਿ ਇਹ ਇੱਕ ਬੁਲੀਅਨ ਹੈ ਇਹ ਦੋ ਮੁੱਲ ਲੈ ਸਕਦਾ ਹੈ - ਇਹ ਸੱਚ ਹੈ и ਝੂਠੇ. ਮੂਲ ਰੂਪ ਵਿੱਚ, ਵਿਕਲਪ ਅਯੋਗ ਹੈ: ਫਲੱਸ਼=ਝੂਠੇ. ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਅੰਦਰੂਨੀ ਬਫਰ ਤੋਂ ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨਾ ਕੇਵਲ ਫਾਈਲ ਦੇ ਬੰਦ ਹੋਣ ਤੋਂ ਬਾਅਦ ਜਾਂ ਸਿੱਧੇ ਕਾਲ ਤੋਂ ਬਾਅਦ ਹੀ ਹੋਵੇਗਾ ਫਲੱਸ਼ (). ਹਰ ਕਾਲ ਤੋਂ ਬਾਅਦ ਬਚਾਉਣ ਲਈ ਛਾਪੋ () ਪੈਰਾਮੀਟਰ ਨੂੰ ਇੱਕ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਇਹ ਸੱਚ ਹੈ:
file_flush = open(r'file_flush.txt', 'a')
ਛਾਪੋ("ਭਰੋਲਾਈਨвਫਾਇਲ«, file=file_flush, flush=True)
ਛਾਪੋ("ਭਰੋਦੂਜਾਲਾਈਨвਫਾਇਲ«, file=file_flush, flush=True)
file_flush.close()
ਪੈਰਾਮੀਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਇੱਕ ਹੋਰ ਉਦਾਹਰਨ ਫਲੱਸ਼ ਟਾਈਮ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ:
ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਦਲੀਲ ਇਹ ਸੱਚ ਹੈ ਪੈਰਾਮੀਟਰ ਫਲੱਸ਼ ਨੰਬਰਾਂ ਨੂੰ ਤਿੰਨ ਸਕਿੰਟਾਂ ਵਿੱਚ ਇੱਕ ਵਾਰ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗਾ, ਜਦੋਂ ਕਿ ਮੂਲ ਰੂਪ ਵਿੱਚ ਸਾਰੇ ਨੰਬਰ 15 ਸਕਿੰਟਾਂ ਬਾਅਦ ਸਕ੍ਰੀਨ 'ਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਹੋਣਗੇ। ਪੈਰਾਮੀਟਰ ਦੇ ਪ੍ਰਭਾਵ ਨੂੰ ਵੇਖਣ ਲਈ ਫਲੱਸ਼, ਕੰਸੋਲ ਵਿੱਚ ਸਕ੍ਰਿਪਟ ਨੂੰ ਚਲਾਉਣਾ ਬਿਹਤਰ ਹੈ। ਤੱਥ ਇਹ ਹੈ ਕਿ ਜਦੋਂ ਕੁਝ ਵੈਬ ਸ਼ੈੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਖਾਸ ਤੌਰ 'ਤੇ, ਜੁਪੀਟਰ ਨੋਟਬੁੱਕ, ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਵੱਖਰੇ ਤਰੀਕੇ ਨਾਲ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ (ਪੈਰਾਮੀਟਰ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਲਏ ਬਿਨਾਂ ਫਲੱਸ਼).
ਪ੍ਰਿੰਟ () ਨਾਲ ਵੇਰੀਏਬਲ ਮੁੱਲਾਂ ਨੂੰ ਛਾਪਣਾ
ਇੱਕ ਵੇਰੀਏਬਲ ਨੂੰ ਨਿਰਧਾਰਤ ਮੁੱਲ ਵਾਲੀ ਇੱਕ ਸਤਰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਕਾਮੇ ਦੁਆਰਾ ਵੱਖ ਕੀਤੇ ਲੋੜੀਂਦੇ ਪਛਾਣਕਰਤਾ (ਵੇਰੀਏਬਲ ਨਾਮ) ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਾਫ਼ੀ ਹੁੰਦਾ ਹੈ। ਵੇਰੀਏਬਲ ਦੀ ਕਿਸਮ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ, ਕਿਉਂਕਿ ਪ੍ਰਿੰਟ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੇ ਡੇਟਾ ਨੂੰ ਸਤਰ ਵਿੱਚ ਬਦਲਦਾ ਹੈ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਨ ਹੈ:
ਨੂੰ = 0
b = 'ਸਕਰੈਚ ਤੋਂ ਪਾਈਥਨ'
ਛਾਪੋ(a,'- ਗਿਣਤੀ, а',ਬੀ,'- ਲਾਈਨ.')
0 ਇੱਕ ਸੰਖਿਆ ਹੈ ਅਤੇ ਸਕ੍ਰੈਚ ਤੋਂ ਪਾਈਥਨ ਇੱਕ ਸਤਰ ਹੈ।
ਆਉਟਪੁੱਟ ਵਿੱਚ ਵੇਰੀਏਬਲ ਮੁੱਲਾਂ ਨੂੰ ਪਾਸ ਕਰਨ ਲਈ ਇੱਕ ਹੋਰ ਸਾਧਨ ਵਿਧੀ ਹੈ ਫਾਰਮੈਟ. ਪ੍ਰਿੰਟ ਉਸੇ ਸਮੇਂ, ਇਹ ਇੱਕ ਟੈਂਪਲੇਟ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਕਰਲੀ ਬਰੇਸ ਵਿੱਚ ਵੇਰੀਏਬਲ ਨਾਵਾਂ ਦੀ ਬਜਾਏ, ਸਥਿਤੀ ਸੰਬੰਧੀ ਆਰਗੂਮੈਂਟਾਂ ਦੇ ਸੂਚਕਾਂਕ ਦਰਸਾਏ ਜਾਂਦੇ ਹਨ:
ਨੂੰ = 0
b = 'ਸਕਰੈਚ ਤੋਂ ਪਾਈਥਨ'
ਪ੍ਰਿੰਟ('{0} ਇੱਕ ਸੰਖਿਆ ਹੈ ਅਤੇ {1} ਇੱਕ ਸਤਰ ਹੈ।'ਫਾਰਮੈਟ(a,b))
0 ਇੱਕ ਸੰਖਿਆ ਹੈ ਅਤੇ ਸਕ੍ਰੈਚ ਤੋਂ ਪਾਈਥਨ ਇੱਕ ਸਤਰ ਹੈ।
ਦੇ ਬਜਾਏ ਫਾਰਮੈਟ % ਚਿੰਨ੍ਹ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਜੋ ਪਲੇਸਹੋਲਡਰ ਦੇ ਸਮਾਨ ਸਿਧਾਂਤ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ (ਪਿਛਲੀ ਉਦਾਹਰਨ ਵਿੱਚ, ਕਰਲੀ ਬਰੈਕਟ ਪਲੇਸਹੋਲਡਰ ਵਜੋਂ ਕੰਮ ਕਰਦੇ ਹਨ)। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਸੂਚਕਾਂਕ ਨੰਬਰਾਂ ਨੂੰ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ ਗਏ ਡੇਟਾ ਕਿਸਮ ਦੁਆਰਾ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ:
- ਪਲੇਸਹੋਲਡਰ %d ਨੂੰ ਸੰਖਿਆਤਮਕ ਡੇਟਾ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ;
- ਪਲੇਸਹੋਲਡਰ %s ਸਤਰ ਲਈ ਹੈ।
ਨੂੰ = 0
b = 'ਸਕਰੈਚ ਤੋਂ ਪਾਈਥਨ'
ਪ੍ਰਿੰਟ('%d ਇੱਕ ਨੰਬਰ ਹੈ ਅਤੇ %s - ਸਤਰ।'%(a,b))
0 ਇੱਕ ਸੰਖਿਆ ਹੈ ਅਤੇ ਸਕ੍ਰੈਚ ਤੋਂ ਪਾਈਥਨ ਇੱਕ ਸਤਰ ਹੈ।
ਜੇਕਰ ਪੂਰਨ ਅੰਕਾਂ ਲਈ ਪਲੇਸਹੋਲਡਰ ਦੀ ਬਜਾਏ %d ਨਿਰਧਾਰਤ ਕਰੋ %sਫੰਕਸ਼ਨ ਪ੍ਰਿੰਟ ਨੰਬਰ ਨੂੰ ਇੱਕ ਸਤਰ ਵਿੱਚ ਬਦਲ ਦੇਵੇਗਾ ਅਤੇ ਕੋਡ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰੇਗਾ। ਪਰ ਜਦੋਂ ਬਦਲਣਾ %s on %d ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ ਕਿਉਂਕਿ ਰਿਵਰਸ ਪਰਿਵਰਤਨ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ।
ਸਿੱਟਾ
ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਪ੍ਰਿੰਟ ਵੱਖ-ਵੱਖ ਡਾਟਾ ਆਉਟਪੁੱਟ ਵਿਕਲਪ ਲਾਗੂ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਇਸ ਲੇਖ ਵਿੱਚ ਵਰਣਿਤ ਤਰੀਕਿਆਂ ਤੋਂ ਇਲਾਵਾ, ਇਸ ਟੂਲ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਹੋਰ ਤਰੀਕੇ ਹਨ ਜੋ ਉਪਲਬਧ ਹੋ ਜਾਣਗੇ ਜਦੋਂ ਤੁਸੀਂ ਪਾਈਥਨ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੀ ਦੁਨੀਆ ਵਿੱਚ ਡੂੰਘਾਈ ਨਾਲ ਖੋਜ ਕਰੋਗੇ।