fileinput --- ਕਈ ਇਨਪੁਟ ਸਟ੍ਰੀਮਾਂ ਤੋਂ ਲਾਈਨਾਂ ਉੱਤੇ ਇਟਰੇਟ ਕਰੋ¶
ਸਰੋਤ ਕੋਡ: Lib/fileinput.py
ਇਹ ਮੌਡਿਊਲ ਸਟੈਂਡਰਡ ਇਨਪੁੱਟ ਜਾਂ ਫ਼ਾਈਲਾਂ ਦੀ ਸੂਚੀ ਉੱਤੇ ਤੇਜ਼ੀ ਨਾਲ ਲੂਪ ਚਲਾਉਣ ਲਈ ਇੱਕ ਸਹਾਇਕ ਕਲਾਸ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ। ਜੇ ਤੁਸੀਂ ਸਿਰਫ਼ ਇੱਕ ਫ਼ਾਈਲ ਪੜ੍ਹਨਾ ਜਾਂ ਲਿਖਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ open() ਵੇਖੋ।
ਆਮ ਵਰਤੋਂ ਇਸ ਪ੍ਰਕਾਰ ਹੈ:
import fileinput
for line in fileinput.input(encoding="utf-8"):
process(line)
ਇਹ sys.argv[1:] ਵਿੱਚ ਦਿੱਤੀਆਂ ਸਾਰੀਆਂ ਫ਼ਾਈਲਾਂ ਦੀਆਂ ਲਾਈਨਾਂ ਨੂੰ ਦੁਹਰਾਉਂਦਾ ਹੈ, ਅਤੇ ਜੇ ਸੂਚੀ ਖਾਲੀ ਹੋਵੇ ਤਾਂ sys.stdin ਨੂੰ ਡਿਫਾਲਟ ਵਜੋਂ ਵਰਤਦਾ ਹੈ। ਜੇ ਫ਼ਾਈਲ ਦਾ ਨਾਮ '-' ਹੈ, ਤਾਂ ਇਸਨੂੰ ਵੀ sys.stdin ਨਾਲ ਬਦਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਵਿਕਲਪਿਕ ਆਰਗੂਮੈਂਟ mode ਅਤੇ openhook ਨੂੰ ਅਣਡਿੱਠਾ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਵਿਕਲਪਿਕ ਫ਼ਾਈਲ ਨਾਮਾਂ ਦੀ ਸੂਚੀ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ, ਇਸਨੂੰ input() ਦੇ ਪਹਿਲੇ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਪਾਸ ਕਰੋ। ਇੱਕ ਸਿੰਗਲ ਫ਼ਾਈਲ ਨਾਮ ਦੀ ਵੀ ਇਜਾਜ਼ਤ ਹੈ।
ਸਾਰੀਆਂ ਫ਼ਾਈਲਾਂ ਮੂਲ ਰੂਪ ਵਿੱਚ ਟੈਕਸਟ ਮੋਡ ਵਿੱਚ ਖੋਲ੍ਹੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਪਰ ਤੁਸੀਂ input() ਜਾਂ FileInput ਨੂੰ ਕਾਲ ਕਰਦੇ ਸਮੇਂ mode ਪੈਰਾਮੀਟਰ ਨਿਰਧਾਰਤ ਕਰਕੇ ਇਸਨੂੰ ਬਦਲ ਸਕਦੇ ਹੋ। ਜੇਕਰ ਕਿਸੇ ਫ਼ਾਈਲ ਨੂੰ ਖੋਲ੍ਹਣ ਜਾਂ ਪੜ੍ਹਨ ਵੇਲੇ I/O ਗਲਤੀ ਹੁੰਦੀ ਹੈ, ਤਾਂ OSError ਉੱਠਾਈ ਜਾਂਦੀ ਹੈ।
ਜੇ sys.stdin ਨੂੰ ਇੱਕ ਤੋਂ ਵੱਧ ਵਾਰ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਦੂਜੀ ਅਤੇ ਇਸ ਤੋਂ ਬਾਅਦ ਦੀ ਹਰ ਵਰਤੋਂ ਕੋਈ ਲਾਈਨ ਵਾਪਸ ਨਹੀਂ ਕਰੇਗੀ, ਸਿਵਾਏ ਇੰਟਰਐਕਟਿਵ ਵਰਤੋਂ ਦੇ, ਜਾਂ ਜੇਕਰ ਇਸਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਰੀਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੋਵੇ (ਉਦਾਹਰਨ ਲਈ, sys.stdin.seek(0) ਦੀ ਵਰਤੋਂ ਕਰਕੇ)।
ਖਾਲੀ ਫਾਈਲਾਂ ਖੋਲ੍ਹੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਅਤੇ ਤੁਰੰਤ ਬੰਦ ਕਰ ਦਿੱਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ; ਫਾਈਲ ਨਾਮਾਂ ਦੀ ਸੂਚੀ ਵਿੱਚ ਉਨ੍ਹਾਂ ਦੀ ਮੌਜੂਦਗੀ ਦਾ ਪਤਾ ਸਿਰਫ਼ ਉਦੋਂ ਲੱਗਦਾ ਹੈ ਜਦੋਂ ਆਖਰੀ ਖੋਲ੍ਹੀ ਗਈ ਫਾਈਲ ਖਾਲੀ ਹੋਵੇ।
ਲਾਈਨਾਂ ਨੂੰ ਉਹਨਾਂ ਦੀਆਂ ਸਾਰੀਆਂ ਨਵੀਆਂ ਲਾਈਨਾਂ ਸਮੇਤ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਫਾਈਲ ਦੀ ਆਖਰੀ ਲਾਈਨ ਦੇ ਅੰਤ ਵਿੱਚ ਨਵੀਂ ਲਾਈਨ ਹੋਣਾ ਜ਼ਰੂਰੀ ਨਹੀਂ ਹੈ।
ਤੁਸੀਂ openhook ਪੈਰਾਮੀਟਰ ਰਾਹੀਂ ਇੱਕ ਓਪਨਿੰਗ ਹੁੱਕ ਦੇ ਕੇ ਇਹ ਨਿਯੰਤਰਿਤ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਫਾਈਲਾਂ ਕਿਵੇਂ ਖੋਲ੍ਹੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਇਹ ਓਪਨਿੰਗ ਹੁੱਕ fileinput.input() ਜਾਂ FileInput() ਨੂੰ ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਹੁੱਕ ਇੱਕ ਅਜਿਹਾ ਫੰਕਸ਼ਨ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਦੋ ਆਰਗੂਮੈਂਟ, filename ਅਤੇ mode, ਲੈਂਦਾ ਹੋਵੇ ਅਤੇ ਉਸ ਅਨੁਸਾਰ ਖੋਲ੍ਹਿਆ ਗਿਆ ਫਾਈਲ-ਵਰਗਾ ਆਬਜੈਕਟ ਵਾਪਸ ਕਰਦਾ ਹੋਵੇ। ਜੇ encoding ਅਤੇ/ਜਾਂ errors ਦਿੱਤੇ ਗਏ ਹਨ, ਤਾਂ ਉਹ ਵਾਧੂ ਕੀਵਰਡ ਆਰਗੂਮੈਂਟਾਂ ਵਜੋਂ ਹੁੱਕ ਨੂੰ ਦਿੱਤੇ ਜਾਣਗੇ। ਇਹ ਮੋਡੀਊਲ ਸੰਕੁਚਿਤ ਫਾਈਲਾਂ ਲਈ hook_compressed() ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।
ਇਸ ਮੋਡੀਊਲ ਦਾ ਮੁੱਖ ਇੰਟਰਫੇਸ ਹੇਠਾਂ ਦਿੱਤਾ ਫੰਕਸ਼ਨ ਹੈ:
- fileinput.input(files=None, inplace=False, backup='', *, mode='r', openhook=None, encoding=None, errors=None)¶
FileInputਕਲਾਸ ਦੀ ਇੱਕ ਇੰਸਟੈਂਸ ਬਣਾਓ। ਇਹ ਇੰਸਟੈਂਸ ਇਸ ਮੋਡੀਊਲ ਦੇ ਫੰਕਸ਼ਨਾਂ ਲਈ ਗਲੋਬਲ ਸਟੇਟ ਵਜੋਂ ਵਰਤੀ ਜਾਵੇਗੀ ਅਤੇ ਇਟਰੇਸ਼ਨ ਦੌਰਾਨ ਵਰਤਣ ਲਈ ਵੀ ਵਾਪਸ ਕੀਤੀ ਜਾਵੇਗੀ। ਇਸ ਫੰਕਸ਼ਨ ਦੇ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰFileInputਕਲਾਸ ਦੇ ਕੰਸਟਰਕਟਰ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਵੇਗਾ।FileInputਇੰਸਟੈਂਸ ਨੂੰwithਸਟੇਟਮੈਂਟ ਵਿੱਚ ਇੱਕ ਕਾਂਟੈਕਸਟ ਮੈਨੇਜਰ ਵਜੋਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ,withwith ਸਟੇਟਮੈਂਟ ਤੋਂ ਬਾਹਰ ਨਿਕਲਣ ਤੋਂ ਬਾਅਦ input ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਭਾਵੇਂ ਕੋਈ ਐਕਸੈਪਸ਼ਨ ਆ ਜਾਵੇ:with fileinput.input(files=('spam.txt', 'eggs.txt'), encoding="utf-8") as f: for line in f: process(line)
Changed in version 3.2: ਕਾਂਟੈਕਸਟ ਮੈਨੇਜਰ ਵਜੋਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।
Changed in version 3.8: ਕੀਵਰਡ ਪੈਰਾਮੀਟਰ mode ਅਤੇ openhook ਹੁਣ ਸਿਰਫ਼ ਕੀਵਰਡ ਵਜੋਂ ਹੀ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ।
Changed in version 3.10: ਕੀਵਰਡ-ਓਨਲੀ ਪੈਰਾਮੀਟਰ encoding ਅਤੇ errors ਸ਼ਾਮਲ ਕੀਤੇ ਗਏ ਹਨ।
ਹੇਠਾਂ ਦਿੱਤੇ ਫੰਕਸ਼ਨ fileinput.input() ਦੁਆਰਾ ਬਣਾਈ ਗਈ ਗਲੋਬਲ ਸਟੇਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ; ਜੇਕਰ ਕੋਈ ਐਕਟਿਵ ਸਟੇਟ ਨਹੀਂ ਹੈ, ਤਾਂ RuntimeError ਉਠਾਇਆ ਜਾਂਦਾ ਹੈ।
- fileinput.filename()¶
ਵਰਤਮਾਨ ਵਿੱਚ ਪੜ੍ਹੀ ਜਾ ਰਹੀ ਫ਼ਾਈਲ ਦਾ ਨਾਮ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਪਹਿਲੀ ਲਾਈਨ ਪੜ੍ਹੇ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ,
Noneਵਾਪਸ ਕਰਦਾ ਹੈ।
- fileinput.fileno()¶
ਮੌਜੂਦਾ ਫਾਈਲ ਲਈ ਪੂਰਨ ਅੰਕ "ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ" ਵਾਪਸ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਕੋਈ ਫਾਈਲ ਖੁੱਲ੍ਹੀ ਨਾ ਹੋਵੇ (ਪਹਿਲੀ ਲਾਈਨ ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ ਫਾਈਲਾਂ ਦੇ ਵਿਚਕਾਰ), ਤਾਂ
-1ਵਾਪਸ ਕਰਦਾ ਹੈ।
- fileinput.lineno()¶
ਹੁਣੇ ਪੜ੍ਹੀ ਗਈ ਲਾਈਨ ਦਾ ਸੰਚਿਤ ਲਾਈਨ ਨੰਬਰ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਪਹਿਲੀ ਲਾਈਨ ਪੜ੍ਹਨ ਤੋਂ ਪਹਿਲਾਂ,
0ਵਾਪਸ ਕਰਦਾ ਹੈ। ਆਖਰੀ ਫਾਈਲ ਦੀ ਆਖਰੀ ਲਾਈਨ ਪੜ੍ਹਨ ਤੋਂ ਬਾਅਦ, ਉਸ ਲਾਈਨ ਦਾ ਲਾਈਨ ਨੰਬਰ ਵਾਪਸ ਕਰਦਾ ਹੈ।
- fileinput.filelineno()¶
ਮੌਜੂਦਾ ਫਾਈਲ ਵਿੱਚ ਲਾਈਨ ਨੰਬਰ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਪਹਿਲੀ ਲਾਈਨ ਪੜ੍ਹਨ ਤੋਂ ਪਹਿਲਾਂ,
0ਵਾਪਸ ਕਰਦਾ ਹੈ। ਆਖਰੀ ਫਾਈਲ ਦੀ ਆਖਰੀ ਲਾਈਨ ਪੜ੍ਹਨ ਤੋਂ ਬਾਅਦ, ਉਸ ਲਾਈਨ ਦਾ ਫਾਈਲ ਦੇ ਅੰਦਰਲਾ ਲਾਈਨ ਨੰਬਰ ਵਾਪਸ ਕਰਦਾ ਹੈ।
- fileinput.isfirstline()¶
ਜੇ ਹੁਣੇ ਪੜ੍ਹੀ ਗਈ ਲਾਈਨ ਉਸ ਫਾਈਲ ਦੀ ਪਹਿਲੀ ਲਾਈਨ ਹੈ ਤਾਂ
Trueਵਾਪਸ ਕਰਦਾ ਹੈ, ਨਹੀਂ ਤਾਂFalseਵਾਪਸ ਕਰਦਾ ਹੈ।
- fileinput.isstdin()¶
ਜੇ ਆਖਰੀ ਲਾਈਨ
sys.stdinਤੋਂ ਪੜ੍ਹੀ ਗਈ ਹੈ ਤਾਂTrueਵਾਪਸ ਕਰਦਾ ਹੈ, ਨਹੀਂ ਤਾਂFalseਵਾਪਸ ਕਰਦਾ ਹੈ।
- fileinput.nextfile()¶
ਮੌਜੂਦਾ ਫਾਈਲ ਨੂੰ ਬੰਦ ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ ਅਗਲੀ ਵਾਰ ਅਗਲੀ ਫਾਈਲ ਦੀ ਪਹਿਲੀ ਲਾਈਨ ਪੜ੍ਹੀ ਜਾਵੇ (ਜੇ ਕੋਈ ਹੋਵੇ); ਫਾਈਲ ਵਿੱਚੋਂ ਨਾ ਪੜ੍ਹੀਆਂ ਗਈਆਂ ਲਾਈਨਾਂ ਕੁੱਲ ਲਾਈਨ ਗਿਣਤੀ ਵਿੱਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੋਣਗੀਆਂ। ਫਾਈਲ ਦਾ ਨਾਮ ਅਗਲੀ ਫਾਈਲ ਦੀ ਪਹਿਲੀ ਲਾਈਨ ਪੜ੍ਹੇ ਜਾਣ ਤੱਕ ਨਹੀਂ ਬਦਲਦਾ। ਪਹਿਲੀ ਲਾਈਨ ਪੜ੍ਹੇ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ, ਇਸ ਫੰਕਸ਼ਨ ਦਾ ਕੋਈ ਅਸਰ ਨਹੀਂ ਹੁੰਦਾ; ਇਸਦੀ ਵਰਤੋਂ ਪਹਿਲੀ ਫਾਈਲ ਨੂੰ ਛੱਡਣ ਲਈ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ। ਆਖਰੀ ਫਾਈਲ ਦੀ ਆਖਰੀ ਲਾਈਨ ਪੜ੍ਹੇ ਜਾਣ ਤੋਂ ਬਾਅਦ, ਇਸ ਫੰਕਸ਼ਨ ਦਾ ਕੋਈ ਅਸਰ ਨਹੀਂ ਹੁੰਦਾ।
- fileinput.close()¶
ਕ੍ਰਮ ਨੂੰ ਬੰਦ ਕਰੋ।
ਮੋਡੀਊਲ ਵੱਲੋਂ ਦਿੱਤੇ ਗਏ ਕ੍ਰਮ ਦੇ ਵਿਹਾਰ ਨੂੰ ਲਾਗੂ ਕਰਨ ਵਾਲੀ ਕਲਾਸ ਨੂੰ ਸਬਕਲਾਸ ਬਣਾਉਣ ਲਈ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ:
- class fileinput.FileInput(files=None, inplace=False, backup='', *, mode='r', openhook=None, encoding=None, errors=None)¶
ਕਲਾਸ
FileInputਇਸਦੀ ਇੰਪਲੀਮੈਂਟੇਸ਼ਨ ਹੈ; ਇਸਦੇ ਢੰਗfilename(),fileno(),lineno(),filelineno(),isfirstline(),isstdin(),nextfile()ਅਤੇclose()ਮੋਡੀਊਲ ਵਿੱਚ ਇਸੇ ਨਾਮ ਵਾਲੇ ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਸੰਬੰਧਿਤ ਹਨ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹ iterable ਹੈ ਅਤੇ ਇਸ ਵਿੱਚreadline()ਢੰਗ ਹੈ ਜੋ ਅਗਲੀ ਇਨਪੁਟ ਲਾਈਨ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਕ੍ਰਮ ਨੂੰ ਸਖ਼ਤ ਕ੍ਰਮਵਾਰ ਢੰਗ ਨਾਲ ਐਕਸੈਸ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ; ਰੈਂਡਮ ਐਕਸੈਸ ਅਤੇreadline()ਨੂੰ ਮਿਲਾ ਕੇ ਨਹੀਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ।*mode* ਨਾਲ ਤੁਸੀਂ ਇਹ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ ਕਿ
open()ਨੂੰ ਕਿਹੜਾ ਫਾਈਲ ਮੋਡ ਦਿੱਤਾ ਜਾਵੇਗਾ। ਇਹ'r'ਜਾਂ'rb'ਵਿੱਚੋਂ ਕੋਈ ਇੱਕ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।*openhook*, ਜੇ ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ, ਇੱਕ ਅਜਿਹਾ ਫੰਕਸ਼ਨ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਦੋ ਆਰਗੂਮੈਂਟ *filename* ਅਤੇ *mode* ਲੈਂਦਾ ਹੈ ਅਤੇ ਇਸ ਅਨੁਸਾਰ ਖੋਲ੍ਹੀ ਗਈ ਫਾਈਲ ਵਰਗੀ ਵਸਤੂ ਵਾਪਸ ਕਰਦਾ ਹੈ।
ਤੁਸੀਂ *encoding* ਅਤੇ *errors* ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ ਜੋ
open()ਜਾਂ *openhook* ਨੂੰ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ।ਇੱਕ
FileInputਇੰਸਟੈਂਸ ਨੂੰwithਸਟੇਟਮੈਂਟ ਵਿੱਚ ਕਾਂਟੈਕਸਟ ਮੈਨੇਜਰ ਵਜੋਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, *input* ਨੂੰwithਸਟੇਟਮੈਂਟ ਤੋਂ ਬਾਹਰ ਨਿਕਲਣ ਤੋਂ ਬਾਅਦ ਬੰਦ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਭਾਵੇਂ ਕੋਈ ਅਪਵਾਦ ਆ ਜਾਵੇ:with FileInput(files=('spam.txt', 'eggs.txt')) as input: process(input)
Changed in version 3.2: ਕਾਂਟੈਕਸਟ ਮੈਨੇਜਰ ਵਜੋਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।
Changed in version 3.8: ਕੀਵਰਡ ਪੈਰਾਮੀਟਰ *mode* ਅਤੇ *openhook* ਹੁਣ ਸਿਰਫ਼ ਕੀਵਰਡ ਵਜੋਂ ਹੀ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ।
Changed in version 3.10: ਕੀਵਰਡ-ਓਨਲੀ ਪੈਰਾਮੀਟਰ encoding ਅਤੇ errors ਸ਼ਾਮਲ ਕੀਤੇ ਗਏ ਹਨ।
Changed in version 3.11:
'rU'ਅਤੇ'U'ਮੋਡ ਅਤੇ :meth:`!__getitem__`ਵਿਧੀ ਨੂੰ ਹਟਾ ਦਿੱਤਾ ਗਿਆ ਹੈ।
ਵਿਕਲਪਿਕ ਇਨ-ਪਲੇਸ ਫਿਲਟਰਿੰਗ: ਜੇ ਕੀਵਰਡ ਆਰਗੂਮੈਂਟ inplace=True ਨੂੰ fileinput.input() ਜਾਂ FileInput ਕਨਸਟਰਕਟਰ ਨੂੰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਫਾਈਲ ਨੂੰ ਬੈਕਅੱਪ ਫਾਈਲ ਵਿੱਚ ਭੇਜ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮਿਆਰੀ ਆਉਟਪੁੱਟ ਨੂੰ ਇਨਪੁਟ ਫਾਈਲ ਵੱਲ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ (ਜੇ ਬੈਕਅੱਪ ਫਾਈਲ ਦੇ ਸਮਾਨ ਨਾਮ ਵਾਲੀ ਫਾਈਲ ਪਹਿਲਾਂ ਤੋਂ ਮੌਜੂਦ ਹੈ, ਤਾਂ ਉਸਨੂੰ ਚੁੱਪਚਾਪ ਬਦਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ)। ਇਸ ਨਾਲ ਕਿਸੇ ਫਿਲਟਰ ਲਈ ਆਪਣੀ ਇਨਪੁਟ ਫਾਈਲ ਨੂੰ ਉਸੇ ਥਾਂ 'ਤੇ ਮੁੜ ਲਿਖਣਾ ਸੰਭਵ ਹੋ ਜਾਂਦਾ ਹੈ। ਜੇ *backup* ਪੈਰਾਮੀਟਰ ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ (ਆਮ ਤੌਰ 'ਤੇ backup='.<some extension>' ਵਜੋਂ), ਤਾਂ ਇਹ ਬੈਕਅੱਪ ਫਾਈਲ ਲਈ ਐਕਸਟੈਂਸ਼ਨ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ, ਅਤੇ ਬੈਕਅੱਪ ਫਾਈਲ ਮੌਜੂਦ ਰਹਿੰਦੀ ਹੈ; ਮੂਲ ਰੂਪ ਵਿੱਚ, ਐਕਸਟੈਂਸ਼ਨ '.bak' ਹੁੰਦੀ ਹੈ ਅਤੇ ਆਉਟਪੁੱਟ ਫਾਈਲ ਬੰਦ ਹੋਣ 'ਤੇ ਇਸਨੂੰ ਮਿਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਜਦੋਂ ਮਿਆਰੀ ਇਨਪੁਟ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਇਨ-ਪਲੇਸ ਫਿਲਟਰਿੰਗ ਅਸਮਰੱਥ ਹੁੰਦੀ ਹੈ।
ਇਸ ਮੋਡੀਊਲ ਵੱਲੋਂ ਹੇਠਾਂ ਦਿੱਤੇ ਦੋ ਓਪਨਿੰਗ ਹੁੱਕ ਪ੍ਰਦਾਨ ਕੀਤੇ ਜਾਂਦੇ ਹਨ:
- fileinput.hook_compressed(filename, mode, *, encoding=None, errors=None)¶
gzip ਅਤੇ bzip2 ਨਾਲ ਸੰਕੁਚਿਤ ਫਾਈਲਾਂ ਨੂੰ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਖੋਲ੍ਹਦਾ ਹੈ (ਜਿਨ੍ਹਾਂ ਨੂੰ
'.gz'ਅਤੇ'.bz2'ਐਕਸਟੈਂਸ਼ਨਾਂ ਰਾਹੀਂ ਪਛਾਣਿਆ ਜਾਂਦਾ ਹੈ),gzipਅਤੇbz2ਮੋਡੀਊਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ। ਜੇ ਫਾਈਲ ਦੀ ਐਕਸਟੈਂਸ਼ਨ'.gz'ਜਾਂ'.bz2'ਨਹੀਂ ਹੈ, ਤਾਂ ਫਾਈਲ ਨੂੰ ਆਮ ਤਰੀਕੇ ਨਾਲ ਖੋਲ੍ਹਿਆ ਜਾਂਦਾ ਹੈ (ਅਰਥਾਤ, ਬਿਨਾਂ ਕਿਸੇ ਡੀਕੰਪ੍ਰੈਸ਼ਨ ਦੇopen()ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ)।ਸੰਕੁਚਿਤ ਫਾਈਲਾਂ ਲਈ ਅਤੇ ਆਮ ਫਾਈਲਾਂ ਨੂੰ ਖੋਲ੍ਹਣ ਲਈ encoding ਅਤੇ errors ਦੇ ਮੁੱਲ
io.TextIOWrapperਨੂੰ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ।ਵਰਤੋਂ ਦੀ ਉਦਾਹਰਨ:
fi = fileinput.FileInput(openhook=fileinput.hook_compressed, encoding="utf-8")Changed in version 3.10: ਕੀਵਰਡ-ਓਨਲੀ ਪੈਰਾਮੀਟਰ encoding ਅਤੇ errors ਸ਼ਾਮਲ ਕੀਤੇ ਗਏ ਹਨ।
- fileinput.hook_encoded(encoding, errors=None)¶
ਇੱਕ ਹੁੱਕ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ ਦਿੱਤੇ ਗਏ encoding ਅਤੇ errors ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹਰ ਫਾਈਲ ਨੂੰ
open()ਨਾਲ ਖੋਲ੍ਹਦਾ ਹੈ ਅਤੇ ਫਾਈਲ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।ਵਰਤੋਂ ਦੀ ਉਦਾਹਰਨ:
fi = fileinput.FileInput(openhook=fileinput.hook_encoded("utf-8", "surrogateescape"))Changed in version 3.6: ਵਿਕਲਪਿਕ errors ਪੈਰਾਮੀਟਰ ਜੋੜਿਆ ਗਿਆ ਹੈ।
Deprecated since version 3.10: ਇਹ ਫੰਕਸ਼ਨ ਪੁਰਾਣਾ ਹੋ ਗਿਆ ਹੈ ਕਿਉਂਕਿ
fileinput.input()ਅਤੇFileInputਵਿੱਚ ਹੁਣ encoding ਅਤੇ errors ਪੈਰਾਮੀਟਰ ਮੌਜੂਦ ਹਨ।