7. ਇਨਪੁੱਟ ਅਤੇ ਆਉਟਪੁੱਟ

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

7.1. ਵਧੇਰੇ ਸ਼ਾਨਦਾਰ ਆਉਟਪੁੱਟ ਫਾਰਮੈਟਿੰਗ

ਹੁਣ ਤੱਕ ਅਸੀਂ ਮੁੱਲਾਂ ਨੂੰ ਦਰਸਾਉਣ ਦੇ ਦੋ ਤਰੀਕਿਆਂ ਨਾਲ ਜਾਣ-ਪਛਾਣ ਕੀਤੀ ਹੈ: expression statements ਅਤੇ print() ਫੰਕਸ਼ਨ। (ਤੀਜਾ ਤਰੀਕਾ ਫਾਈਲ ਆਬਜੈਕਟਾਂ ਦੀ write() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੈ; ਮਿਆਰੀ ਆਉਟਪੁੱਟ ਫਾਈਲ ਨੂੰ sys.stdout ਰਾਹੀਂ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ Library Reference ਵੇਖੋ।)

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

  • formatted string literals ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ, ਸਟ੍ਰਿੰਗ ਦੇ ਸ਼ੁਰੂਆਤੀ quotation mark ਜਾਂ triple quotation mark ਤੋਂ ਪਹਿਲਾਂ f ਜਾਂ F ਲਗਾਓ। ਇਸ ਸਟ੍ਰਿੰਗ ਦੇ ਅੰਦਰ ਤੁਸੀਂ { ਅਤੇ } ਦੇ ਵਿਚਕਾਰ ਕੋਈ Python expression ਲਿਖ ਸਕਦੇ ਹੋ ਜੋ ਚਲਾਂ ਜਾਂ literal ਮੁੱਲਾਂ ਦਾ ਹਵਾਲਾ ਦੇ ਸਕਦਾ ਹੈ।

    >>> year = 2016
>>> event = 'Referendum'
>>> f'Results of the {year} {event}'
'Results of the 2016 Referendum'

  • ਸਟ੍ਰਿੰਗਾਂ ਦੀ str.format() ਵਿਧੀ ਲਈ ਵਧੇਰੇ ਹੱਥੋਂ ਕੀਤੀ ਜਾਣ ਵਾਲੀ ਮਿਹਨਤ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਤੁਸੀਂ ਹਾਲੇ ਵੀ { ਅਤੇ } ਦੀ ਵਰਤੋਂ ਇਹ ਦਰਸਾਉਣ ਲਈ ਕਰੋਗੇ ਕਿ ਕਿਸ ਥਾਂ ਚਲ ਨੂੰ ਬਦਲਿਆ ਜਾਵੇਗਾ ਅਤੇ ਵਿਸਥਾਰਪੂਰਵਕ ਫਾਰਮੈਟਿੰਗ ਨਿਰਦੇਸ਼ ਵੀ ਦੇ ਸਕਦੇ ਹੋ, ਪਰ ਤੁਹਾਨੂੰ ਫਾਰਮੈਟ ਕੀਤੀ ਜਾਣ ਵਾਲੀ ਜਾਣਕਾਰੀ ਵੀ ਪ੍ਰਦਾਨ ਕਰਨੀ ਪਵੇਗੀ। ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਬਲਾਕ ਵਿੱਚ ਚਲਾਂ ਨੂੰ ਫਾਰਮੈਟ ਕਰਨ ਦੇ ਦੋ ਉਦਾਹਰਨ ਹਨ:

    >>> yes_votes = 42_572_654
>>> total_votes = 85_705_149
>>> percentage = yes_votes / total_votes
>>> '{:-9} YES votes  {:2.2%}'.format(yes_votes, percentage)
' 42572654 YES votes  49.67%'

    ਧਿਆਨ ਦਿਓ ਕਿ yes_votes ਨੂੰ ਖਾਲੀ ਥਾਵਾਂ ਨਾਲ ਭਰਿਆ ਗਿਆ ਹੈ ਅਤੇ ਰਿਣਾਤਮਕ ਸੰਖਿਆਵਾਂ ਲਈ ਹੀ ਰਿਣ ਚਿੰਨ੍ਹ ਦਿਖਾਇਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਉਦਾਹਰਨ percentage ਨੂੰ 100 ਨਾਲ ਗੁਣਾ ਕਰਕੇ, ਦਸ਼ਮਲਵ ਤੋਂ ਬਾਅਦ 2 ਅੰਕਾਂ ਸਮੇਤ ਅਤੇ ਪ੍ਰਤੀਸ਼ਤ ਚਿੰਨ੍ਹ ਨਾਲ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦੀ ਹੈ (Format specification mini-language ਵੇਰਵਿਆਂ ਲਈ ਵੇਖੋ)।

  • ਅੰਤ ਵਿੱਚ, ਤੁਸੀਂ ਸਟ੍ਰਿੰਗ slicing ਅਤੇ concatenation ਕਾਰਵਾਈਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣੀ ਕਲਪਨਾ ਅਨੁਸਾਰ ਕੋਈ ਵੀ ਲੇਆਉਟ ਤਿਆਰ ਕਰ ਸਕਦੇ ਹੋ। ਸਟ੍ਰਿੰਗ ਕਿਸਮ ਵਿੱਚ ਕੁਝ ਅਜਿਹੀਆਂ ਵਿਧੀਆਂ ਹਨ ਜੋ ਸਟ੍ਰਿੰਗਾਂ ਨੂੰ ਨਿਰਧਾਰਿਤ ਕਾਲਮ ਚੌੜਾਈ ਤੱਕ ਭਰਨ ਲਈ ਉਪਯੋਗੀ ਕਾਰਵਾਈਆਂ ਕਰਦੀਆਂ ਹਨ।

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

str() ਫੰਕਸ਼ਨ ਦਾ ਉਦੇਸ਼ ਉਹ ਰੂਪ ਵਾਪਸ ਕਰਨਾ ਹੈ ਜੋ ਮਨੁੱਖਾਂ ਲਈ ਆਸਾਨੀ ਨਾਲ ਪੜ੍ਹਨਯੋਗ ਹੋਣ, ਜਦਕਿ repr() ਦਾ ਉਦੇਸ਼ ਅਜਿਹੇ representation ਤਿਆਰ ਕਰਨਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ interpreter ਦੁਆਰਾ ਪੜ੍ਹਿਆ ਜਾ ਸਕੇ (ਜਾਂ ਜੇ ਉਸਦਾ ਸਮਕੱਖ syntax ਮੌਜੂਦ ਨਾ ਹੋਵੇ ਤਾਂ SyntaxError ਪੈਦਾ ਹੋਵੇ)। ਉਹਨਾਂ ਆਬਜੈਕਟਾਂ ਲਈ ਜਿਨ੍ਹਾਂ ਦੀ ਮਨੁੱਖੀ ਵਰਤੋਂ ਲਈ ਕੋਈ ਖਾਸ representation ਨਹੀਂ ਹੁੰਦੀ, str() ਉਹੀ ਮੁੱਲ ਵਾਪਸ ਕਰੇਗਾ ਜੋ repr() ਵਾਪਸ ਕਰਦਾ ਹੈ। ਕਈ ਮੁੱਲਾਂ, ਜਿਵੇਂ ਸੰਖਿਆਵਾਂ ਜਾਂ lists ਅਤੇ dictionaries ਵਰਗੀਆਂ ਬਣਤਰਾਂ ਲਈ, ਦੋਵੇਂ ਫੰਕਸ਼ਨ ਇੱਕੋ representation ਦਿੰਦੇ ਹਨ। ਖਾਸ ਤੌਰ 'ਤੇ, strings ਦੀਆਂ ਦੋ ਵੱਖ-ਵੱਖ representations ਹੁੰਦੀਆਂ ਹਨ।

ਕੁਝ ਉਦਾਹਰਨਾਂ:

>>> s = 'Hello, world.'
>>> str(s)
'Hello, world.'
>>> repr(s)
"'Hello, world.'"
>>> str(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
>>> print(s)
The value of x is 32.5, and y is 40000...
>>> # The repr() of a string adds string quotes and backslashes:
>>> hello = 'hello, world\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, world\n'
>>> # The argument to repr() may be any Python object:
>>> repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"

string ਮੌਡਿਊਲ string.Template ਰਾਹੀਂ regular expressions ਅਧਾਰਿਤ ਇੱਕ ਸਧਾਰਣ template ਪਹੁੰਚ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ। ਇਹ ਸਟ੍ਰਿੰਗਾਂ ਵਿੱਚ ਮੁੱਲ ਸ਼ਾਮਲ ਕਰਨ ਦਾ ਇੱਕ ਹੋਰ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ $x ਵਰਗੇ placeholder ਵਰਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ dictionary ਵਿੱਚ ਮੌਜੂਦ ਮੁੱਲਾਂ ਨਾਲ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ syntax ਵਰਤਣ ਵਿੱਚ ਆਸਾਨ ਹੈ, ਹਾਲਾਂਕਿ ਇਹ ਫਾਰਮੈਟਿੰਗ ਉੱਤੇ ਕਾਫ਼ੀ ਘੱਟ ਨਿਯੰਤਰਣ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

7.1.1. ਫਾਰਮੈਟ ਕੀਤੇ ਸਟਰਿੰਗ ਲਿਟਰਲ

Formatted string literals (ਜਿਨ੍ਹਾਂ ਨੂੰ ਸੰਖੇਪ ਵਿੱਚ f-strings ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ) ਤੁਹਾਨੂੰ ਸਟ੍ਰਿੰਗ ਦੇ ਅੰਦਰ Python expressions ਦੇ ਮੁੱਲ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀਆਂ ਹਨ। ਇਸ ਲਈ ਸਟ੍ਰਿੰਗ ਦੇ ਅੱਗੇ f ਜਾਂ F ਲਗਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ expressions ਨੂੰ {expression} ਦੇ ਰੂਪ ਵਿੱਚ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ।

Expression ਤੋਂ ਬਾਅਦ ਇੱਕ ਵਿਕਲਪਿਕ format specifier ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ ਮੁੱਲ ਨੂੰ ਫਾਰਮੈਟ ਕਰਨ ਦੇ ਤਰੀਕੇ ਉੱਤੇ ਵਧੇਰੇ ਨਿਯੰਤਰਣ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਨ pi ਨੂੰ ਦਸ਼ਮਲਵ ਤੋਂ ਬਾਅਦ ਤਿੰਨ ਅੰਕਾਂ ਤੱਕ ਗੋਲ ਕਰਦੀ ਹੈ:

>>> import math
>>> print(f'The value of pi is approximately {math.pi:.3f}.')
The value of pi is approximately 3.142.

':' ਤੋਂ ਬਾਅਦ ਇੱਕ ਪੂਰਨ ਅੰਕ ਦੇਣ ਨਾਲ ਉਸ field ਦੀ ਘੱਟੋ-ਘੱਟ ਚੌੜਾਈ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਅਨੁਸਾਰ ਨਿਰਧਾਰਿਤ ਹੋ ਜਾਂਦੀ ਹੈ। ਇਹ ਕਾਲਮਾਂ ਨੂੰ ਇੱਕਸਾਰ ਲਾਈਨ ਵਿੱਚ ਰੱਖਣ ਲਈ ਉਪਯੋਗੀ ਹੈ।

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> for name, phone in table.items():
...     print(f'{name:10} ==> {phone:10d}')
...
Sjoerd     ==>       4127
Jack       ==>       4098
Dcab       ==>       7678

ਮੁੱਲ ਨੂੰ ਫਾਰਮੈਟ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਉਸ ਨੂੰ ਬਦਲਣ ਲਈ ਹੋਰ modifiers ਵੀ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ। '!a' ascii() ਲਾਗੂ ਕਰਦਾ ਹੈ, '!s' str() ਲਾਗੂ ਕਰਦਾ ਹੈ ਅਤੇ '!r' repr() ਲਾਗੂ ਕਰਦਾ ਹੈ:

>>> animals = 'eels'
>>> print(f'My hovercraft is full of {animals}.')
My hovercraft is full of eels.
>>> print(f'My hovercraft is full of {animals!r}.')
My hovercraft is full of 'eels'.

= specifier ਦੀ ਵਰਤੋਂ ਕਿਸੇ expression ਨੂੰ ਉਸਦੇ ਟੈਕਸਟ, ਇੱਕ ਬਰਾਬਰ ਚਿੰਨ੍ਹ ਅਤੇ ਫਿਰ ਮੁਲਾਂਕਿਤ expression ਦੀ representation ਵਿੱਚ ਵਿਸਤਾਰਿਤ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ:

>>> bugs = 'roaches'
>>> count = 13
>>> area = 'living room'
>>> print(f'Debugging {bugs=} {count=} {area=}')
Debugging bugs='roaches' count=13 area='living room'

= specifier ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ self-documenting expressions ਵੇਖੋ। ਇਨ੍ਹਾਂ format specifications ਦੇ ਹਵਾਲੇ ਲਈ Format specification mini-language ਦੀ reference guide ਵੇਖੋ।

7.1.2. ਸਟ੍ਰਿੰਗ format() ਵਿਧੀ

str.format() ਵਿਧੀ ਦੀ ਬੁਨਿਆਦੀ ਵਰਤੋਂ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ:

>>> print('We are the {} who say "{}!"'.format('knights', 'Ni'))
We are the knights who say "Ni!"

ਉਨ੍ਹਾਂ ਬ੍ਰੈਕਟਾਂ ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ ਅੰਦਰਲੇ ਅੱਖਰਾਂ (ਜਿਨ੍ਹਾਂ ਨੂੰ format fields ਕਿਹਾ ਜਾਂਦਾ ਹੈ) ਨੂੰ str.format() ਮੈਥਡ ਵਿੱਚ ਪਾਸ ਕੀਤੇ ਗਏ ਆਬਜੈਕਟਾਂ ਨਾਲ ਬਦਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਬ੍ਰੈਕਟਾਂ ਦੇ ਅੰਦਰ ਦਿੱਤਾ ਗਿਆ ਇੱਕ ਨੰਬਰ str.format() ਮੈਥਡ ਵਿੱਚ ਪਾਸ ਕੀਤੇ ਗਏ ਆਬਜੈਕਟ ਦੀ ਸਥਿਤੀ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

>>> print('{0} and {1}'.format('spam', 'eggs'))
spam and eggs
>>> print('{1} and {0}'.format('spam', 'eggs'))
eggs and spam

ਜੇ str.format() ਵਿਧੀ ਵਿੱਚ keyword arguments ਵਰਤੇ ਜਾਣ, ਤਾਂ ਉਨ੍ਹਾਂ ਦੇ ਮੁੱਲਾਂ ਦਾ ਹਵਾਲਾ argument ਦੇ ਨਾਮ ਰਾਹੀਂ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।

>>> print('This {food} is {adjective}.'.format(
...       food='spam', adjective='absolutely horrible'))
This spam is absolutely horrible.

Positional ਅਤੇ keyword arguments ਨੂੰ ਮਨਮਰਜ਼ੀ ਅਨੁਸਾਰ ਇਕੱਠੇ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ:

>>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',
...                                                    other='Georg'))
The story of Bill, Manfred, and Georg.

ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਬਹੁਤ ਲੰਬੀ format string ਹੈ ਜਿਸਨੂੰ ਤੁਸੀਂ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਣਾ ਨਹੀਂ ਚਾਹੁੰਦੇ, ਤਾਂ ਸਥਿਤੀ ਦੀ ਬਜਾਏ ਨਾਮ ਰਾਹੀਂ format ਕੀਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ variables ਨੂੰ ਸੰਬੋਧਨ ਕਰਨਾ ਹੋਰ ਸੁਵਿਧਾਜਨਕ ਹੁੰਦਾ ਹੈ। ਇਹ ਕੰਮ dict ਨੂੰ ਸਿੱਧਾ ਪਾਸ ਕਰਕੇ ਅਤੇ keys ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ square brackets '[]' ਵਰਤ ਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
...       'Dcab: {0[Dcab]:d}'.format(table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

ਇਹ ਕੰਮ table dictionary ਨੂੰ ** notation ਨਾਲ keyword arguments ਵਜੋਂ ਪਾਸ ਕਰਕੇ ਵੀ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

ਇਹ built-in function vars() ਨਾਲ ਮਿਲਾ ਕੇ ਖਾਸ ਤੌਰ 'ਤੇ ਲਾਭਦਾਇਕ ਹੈ, ਜੋ ਸਾਰੇ local variables ਵਾਲੀ dictionary ਵਾਪਸ ਕਰਦਾ ਹੈ:

>>> table = {k: str(v) for k, v in vars().items()}
>>> message = " ".join([f'{k}: ' + '{' + k +'};' for k in table.keys()])
>>> print(message.format(**table))
__name__: __main__; __doc__: None; __package__: None; __loader__: ...

ਉਦਾਹਰਨ ਵਜੋਂ, ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਲਾਈਨਾਂ ਪੂਰਨ ਅੰਕਾਂ ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ ਵਰਗਾਂ ਅਤੇ ਘਣਾਂ ਨੂੰ ਸਾਫ਼-ਸੁਥਰੇ ਢੰਗ ਨਾਲ ਕਾਲਮਾਂ ਵਿੱਚ ਦਰਸਾਉਂਦੀਆਂ ਹਨ:

>>> for x in range(1, 11):
...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

str.format() ਨਾਲ ਸਟ੍ਰਿੰਗ ਫਾਰਮੈਟਿੰਗ ਦੀ ਪੂਰੀ ਜਾਣਕਾਰੀ ਲਈ Format string syntax ਵੇਖੋ।

7.1.3. ਹੱਥੋਂ ਸਟ੍ਰਿੰਗ ਫਾਰਮੈਟਿੰਗ

ਇੱਥੇ ਵਰਗਾਂ ਅਤੇ ਘਣਾਂ ਦੀ ਉਹੀ ਸਾਰਣੀ ਹੈ, ਜਿਸ ਨੂੰ ਹੱਥੋਂ ਫਾਰਮੈਟ ਕੀਤਾ ਗਿਆ ਹੈ:

>>> for x in range(1, 11):
...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
...     # Note use of 'end' on previous line
...     print(repr(x*x*x).rjust(4))
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

(ਧਿਆਨ ਦਿਓ ਕਿ ਹਰ ਕਾਲਮ ਦੇ ਵਿਚਕਾਰ ਦੀ ਇੱਕ ਖਾਲੀ ਥਾਂ print() ਦੇ ਕੰਮ ਕਰਨ ਦੇ ਤਰੀਕੇ ਕਾਰਨ ਜੋੜੀ ਗਈ ਹੈ: ਇਹ ਹਮੇਸ਼ਾਂ ਆਪਣੇ arguments ਦੇ ਵਿਚਕਾਰ ਖਾਲੀ ਥਾਵਾਂ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ।)

ਸਟ੍ਰਿੰਗ ਆਬਜੈਕਟਾਂ ਦੀ str.rjust() ਵਿਧੀ ਖੱਬੇ ਪਾਸੇ ਖਾਲੀ ਥਾਵਾਂ ਜੋੜ ਕੇ ਸਟ੍ਰਿੰਗ ਨੂੰ ਨਿਰਧਾਰਿਤ ਚੌੜਾਈ ਵਾਲੇ field ਵਿੱਚ ਸੱਜੇ ਪਾਸੇ ਸੰਰਿਖਤ ਕਰਦੀ ਹੈ। ਇਸ ਵਰਗੀਆਂ ਹੋਰ ਵਿਧੀਆਂ str.ljust() ਅਤੇ str.center() ਵੀ ਹਨ। ਇਹ ਵਿਧੀਆਂ ਕੁਝ ਵੀ ਨਹੀਂ ਲਿਖਦੀਆਂ, ਸਗੋਂ ਇੱਕ ਨਵੀਂ ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕਰਦੀਆਂ ਹਨ। ਜੇ input ਸਟ੍ਰਿੰਗ ਬਹੁਤ ਲੰਬੀ ਹੋਵੇ ਤਾਂ ਇਹ ਉਸ ਨੂੰ ਕੱਟਦੀਆਂ ਨਹੀਂ, ਸਗੋਂ ਬਿਨਾਂ ਬਦਲਾਅ ਦੇ ਵਾਪਸ ਕਰਦੀਆਂ ਹਨ; ਇਸ ਨਾਲ ਤੁਹਾਡਾ ਕਾਲਮ ਲੇਆਉਟ ਖਰਾਬ ਹੋ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਕਿਸੇ ਮੁੱਲ ਨੂੰ ਗਲਤ ਤਰੀਕੇ ਨਾਲ ਦਰਸਾਉਣ ਨਾਲੋਂ ਬਿਹਤਰ ਹੈ। (ਜੇ ਤੁਸੀਂ ਵਾਸਤਵ ਵਿੱਚ truncation ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ x.ljust(n)[:n] ਵਾਂਗ slice operation ਵਰਤ ਸਕਦੇ ਹੋ।)

ਇੱਕ ਹੋਰ ਤਰੀਕਾ ਹੈ, str.zfill(), ਜੋ ਇੱਕ ਸੰਖਿਆਤਮਕ ਸਟਰਿੰਗ ਨੂੰ ਖੱਬੇ ਪਾਸੇ ਤੋਂ ਸ਼ੂਨਿਆਂ ਨਾਲ ਪੈਡ ਕਰਦਾ ਹੈ। ਇਹ ਪਲੱਸ ਅਤੇ ਮਾਈਨਸ ਚਿੰਨ੍ਹਾਂ ਨੂੰ ਸਮਝਦਾ ਹੈ:

>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'

7.1.4. ਪੁਰਾਣੀ ਸਟ੍ਰਿੰਗ ਫਾਰਮੈਟਿੰਗ

ਸਟ੍ਰਿੰਗ ਫਾਰਮੈਟਿੰਗ ਲਈ % operator (modulo) ਦੀ ਵਰਤੋਂ ਵੀ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। format % values ਵਿੱਚ (ਜਿੱਥੇ format ਇੱਕ ਸਟ੍ਰਿੰਗ ਹੈ), format ਵਿੱਚ ਮੌਜੂਦ % conversion specifications ਨੂੰ values ਦੇ ਸਿਫ਼ਰ ਜਾਂ ਵੱਧ ਤੱਤਾਂ ਨਾਲ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਕਾਰਵਾਈ ਨੂੰ ਆਮ ਤੌਰ 'ਤੇ string interpolation ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ:

>>> import math
>>> print('The value of pi is approximately %5.3f.' % math.pi)
The value of pi is approximately 3.142.

ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ printf-style String Formatting ਭਾਗ ਵੇਖੋ।

7.2. ਫਾਈਲਾਂ ਨੂੰ ਪੜ੍ਹਨਾ ਅਤੇ ਲਿਖਣਾ

open() ਇੱਕ file object ਵਾਪਸ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਦੀ ਸਭ ਤੋਂ ਆਮ ਵਰਤੋਂ ਦੋ ਸਥਿਤੀਗਤ ਆਰਗੂਮੈਂਟਾਂ ਨਾਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ: open(filename, mode)

>>> f = open('workfile', 'w')

ਪਹਿਲਾ argument ਇੱਕ ਸਟ੍ਰਿੰਗ ਹੈ ਜਿਸ ਵਿੱਚ ਫਾਈਲ ਦਾ ਨਾਮ ਹੁੰਦਾ ਹੈ। ਦੂਜਾ argument ਇੱਕ ਹੋਰ ਸਟ੍ਰਿੰਗ ਹੈ ਜਿਸ ਵਿੱਚ ਕੁਝ ਅੱਖਰ ਹੁੰਦੇ ਹਨ ਜੋ ਇਹ ਦਰਸਾਉਂਦੇ ਹਨ ਕਿ ਫਾਈਲ ਕਿਸ ਤਰੀਕੇ ਨਾਲ ਵਰਤੀ ਜਾਵੇਗੀ। mode ਇਹ ਹੋ ਸਕਦਾ ਹੈ: 'r' ਜਦੋਂ ਫਾਈਲ ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ ਹੋਵੇ, 'w' ਸਿਰਫ਼ ਲਿਖਣ ਲਈ (ਉਸੇ ਨਾਮ ਦੀ ਮੌਜੂਦਾ ਫਾਈਲ ਮਿਟਾ ਦਿੱਤੀ ਜਾਵੇਗੀ), ਅਤੇ 'a' ਫਾਈਲ ਨੂੰ ਅੰਤ ਵਿੱਚ ਜੋੜਨ ਲਈ ਖੋਲ੍ਹਦਾ ਹੈ; ਫਾਈਲ ਵਿੱਚ ਲਿਖਿਆ ਕੋਈ ਵੀ ਡਾਟਾ ਆਪਣੇ ਆਪ ਅੰਤ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋ ਜਾਂਦਾ ਹੈ। 'r+' ਫਾਈਲ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਦੋਹਾਂ ਲਈ ਖੋਲ੍ਹਦਾ ਹੈ। mode argument ਵਿਕਲਪਿਕ ਹੈ; ਜੇ ਇਹ ਛੱਡ ਦਿੱਤਾ ਜਾਵੇ ਤਾਂ 'r' ਮੰਨਿਆ ਜਾਵੇਗਾ।

ਆਮ ਤੌਰ 'ਤੇ, ਫਾਈਲਾਂ ਨੂੰ text mode ਵਿੱਚ ਖੋਲ੍ਹਿਆ ਜਾਂਦਾ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ਫਾਈਲ ਵਿੱਚ ਸਟ੍ਰਿੰਗਾਂ ਪੜ੍ਹਦੇ ਅਤੇ ਲਿਖਦੇ ਹੋ, ਜੋ ਇੱਕ ਨਿਰਧਾਰਤ encoding ਵਿੱਚ ਏਨਕੋਡ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਜੇ encoding ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ, ਤਾਂ ਡਿਫੌਲਟ UTF-8 ਹੁੰਦੀ ਹੈ (open() ਵੇਖੋ)। ਮੋਡ ਵਿੱਚ 'b' ਜੋੜਨ ਨਾਲ ਫਾਈਲ binary mode ਵਿੱਚ ਖੁੱਲ੍ਹਦੀ ਹੈ। ਬਾਈਨਰੀ ਮੋਡ ਦਾ ਡਾਟਾ bytes ਆਬਜੈਕਟਾਂ ਵਜੋਂ ਪੜ੍ਹਿਆ ਅਤੇ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ। ਬਾਈਨਰੀ ਮੋਡ ਵਿੱਚ ਫਾਈਲ ਖੋਲ੍ਹਦੇ ਸਮੇਂ ਤੁਸੀਂ encoding ਨਿਰਧਾਰਤ ਨਹੀਂ ਕਰ ਸਕਦੇ।

ਟੈਕਸਟ ਮੋਡ ਵਿੱਚ, ਪੜ੍ਹਨ ਵੇਲੇ ਡਿਫੌਲਟ ਇਹ ਹੁੰਦਾ ਹੈ ਕਿ ਪਲੇਟਫਾਰਮ-ਵਿਸ਼ੇਸ਼ ਲਾਈਨ ਅੰਤ (Unix 'ਤੇ \n, Windows 'ਤੇ \r\n ) ਨੂੰ ਸਿਰਫ਼ \n ਵਿੱਚ ਬਦਲਿਆ ਜਾਵੇ। ਜਦੋਂ ਟੈਕਸਟ ਮੋਡ ਵਿੱਚ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਡਿਫੌਲਟ ਇਹ ਹੁੰਦਾ ਹੈ ਕਿ \n ਦੀਆਂ ਘਟਨਾਵਾਂ ਨੂੰ ਮੁੜ ਪਲੇਟਫਾਰਮ-ਵਿਸ਼ੇਸ਼ ਲਾਈਨ ਅੰਤਾਂ ਵਿੱਚ ਬਦਲਿਆ ਜਾਵੇ। ਫਾਈਲ ਡੇਟਾ ਵਿੱਚ ਇਹ ਪਰਦੇ ਪਿੱਛੇ ਕੀਤੀ ਗਈ ਤਬਦੀਲੀ ਟੈਕਸਟ ਫਾਈਲਾਂ ਲਈ ਠੀਕ ਹੈ, ਪਰ ਇਹ JPEG ਜਾਂ EXE ਵਰਗੀਆਂ ਬਾਈਨਰੀ ਫਾਈਲਾਂ ਦੇ ਡੇਟਾ ਨੂੰ ਖਰਾਬ ਕਰ ਦੇਵੇਗੀ। ਅਜਿਹੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਵੇਲੇ ਬਾਈਨਰੀ ਮੋਡ ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਿੱਚ ਬਹੁਤ ਸਾਵਧਾਨ ਰਹੋ।

ਫਾਈਲ ਆਬਜੈਕਟਾਂ ਨਾਲ ਨਿਪਟਦਿਆਂ with ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਚੰਗਾ ਅਭਿਆਸ ਹੈ। ਇਸਦਾ ਫਾਇਦਾ ਇਹ ਹੈ ਕਿ ਸੂਟ ਖਤਮ ਹੋਣ 'ਤੇ ਫਾਈਲ ਠੀਕ ਤਰ੍ਹਾਂ ਬੰਦ ਹੋ ਜਾਂਦੀ ਹੈ, ਭਾਵੇਂ ਕਿਸੇ ਵੀ ਸਮੇਂ ਐਕਸੈਪਸ਼ਨ ਉਠਾਈ ਜਾਵੇ। with ਦੀ ਵਰਤੋਂ ਵੀ ਬਰਾਬਰ ਦੇ try-finally ਬਲਾਕਾਂ ਨੂੰ ਲਿਖਣ ਨਾਲੋਂ ਕਾਫੀ ਛੋਟੀ ਹੈ।

>>> with open('workfile') as f:
...     read_data = f.read()

>>> # We can check that the file has been automatically closed.
>>> f.closed
True

ਜੇ ਤੁਸੀਂ with keyword ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਫਾਈਲ ਨੂੰ ਬੰਦ ਕਰਨ ਅਤੇ ਇਸ ਦੁਆਰਾ ਵਰਤੇ ਗਏ ਸਿਸਟਮ ਸਰੋਤਾਂ ਨੂੰ ਤੁਰੰਤ ਮੁਕਤ ਕਰਨ ਲਈ f.close() ਨੂੰ ਕਾਲ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।

Warning

with keyword ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ ਜਾਂ f.close() ਨੂੰ ਕਾਲ ਕੀਤੇ ਬਿਨਾਂ f.write() ਨੂੰ ਕਾਲ ਕਰਨ ਨਾਲ ਸੰਭਵ ਹੈ ਕਿ f.write() ਦੇ arguments ਪੂਰੀ ਤਰ੍ਹਾਂ ਡਿਸਕ ਉੱਤੇ ਨਾ ਲਿਖੇ ਜਾਣ, ਭਾਵੇਂ ਪ੍ਰੋਗਰਾਮ ਸਫਲਤਾਪੂਰਵਕ ਸਮਾਪਤ ਹੀ ਕਿਉਂ ਨਾ ਹੋ ਜਾਵੇ।

ਫਾਈਲ ਆਬਜੈਕਟ ਬੰਦ ਹੋ ਜਾਣ ਤੋਂ ਬਾਅਦ, ਚਾਹੇ ਉਹ with statement ਰਾਹੀਂ ਬੰਦ ਕੀਤਾ ਗਿਆ ਹੋਵੇ ਜਾਂ f.close() ਨੂੰ ਕਾਲ ਕਰਕੇ, ਉਸ ਫਾਈਲ ਆਬਜੈਕਟ ਨੂੰ ਵਰਤਣ ਦੀਆਂ ਕੋਸ਼ਿਸ਼ਾਂ ਆਪਣੇ ਆਪ ਅਸਫਲ ਹੋ ਜਾਣਗੀਆਂ।

>>> f.close()
>>> f.read()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: I/O operation on closed file.

7.2.1. ਫਾਈਲ ਆਬਜੈਕਟਾਂ ਦੀਆਂ ਵਿਧੀਆਂ

ਇਸ ਭਾਗ ਵਿੱਚ ਬਾਕੀ ਸਾਰੀਆਂ ਉਦਾਹਰਨਾਂ ਇਹ ਮੰਨ ਕੇ ਚੱਲਣਗੀਆਂ ਕਿ f ਨਾਮ ਦਾ ਇੱਕ ਫਾਈਲ ਆਬਜੈਕਟ ਪਹਿਲਾਂ ਹੀ ਬਣਾਇਆ ਜਾ ਚੁੱਕਾ ਹੈ।

ਫਾਈਲ ਦੀ ਸਮੱਗਰੀ ਪੜ੍ਹਨ ਲਈ f.read(size) ਨੂੰ ਕਾਲ ਕਰੋ, ਜੋ ਕੁਝ ਮਾਤਰਾ ਵਿੱਚ ਡਾਟਾ ਪੜ੍ਹਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ string (text mode ਵਿੱਚ) ਜਾਂ bytes object (binary mode ਵਿੱਚ) ਵਜੋਂ ਵਾਪਸ ਕਰਦਾ ਹੈ। size ਇੱਕ ਵਿਕਲਪਿਕ ਸੰਖਿਆਤਮਕ argument ਹੈ। ਜਦੋਂ size ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾਵੇ ਜਾਂ ਨਕਾਰਾਤਮਕ ਹੋਵੇ, ਤਾਂ ਫਾਈਲ ਦੀ ਪੂਰੀ ਸਮੱਗਰੀ ਪੜ੍ਹ ਕੇ ਵਾਪਸ ਕੀਤੀ ਜਾਵੇਗੀ; ਜੇ ਫਾਈਲ ਤੁਹਾਡੀ machine ਦੀ memory ਨਾਲੋਂ ਦੋ ਗੁਣਾ ਵੱਡੀ ਹੋਵੇ ਤਾਂ ਇਹ ਤੁਹਾਡੀ ਸਮੱਸਿਆ ਹੈ। ਨਹੀਂ ਤਾਂ, ਵੱਧ ਤੋਂ ਵੱਧ size ਅੱਖਰ (text mode ਵਿੱਚ) ਜਾਂ size bytes (binary mode ਵਿੱਚ) ਪੜ੍ਹੇ ਅਤੇ ਵਾਪਸ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਜੇ ਫਾਈਲ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੋਵੇ, ਤਾਂ f.read() ਇੱਕ ਖਾਲੀ string ('') ਵਾਪਸ ਕਰੇਗਾ।

>>> f.read()
'This is the entire file.\n'
>>> f.read()
''

f.readline() ਫਾਈਲ ਤੋਂ ਇੱਕ ਲਾਈਨ ਪੜ੍ਹਦਾ ਹੈ; ਸਟਰਿੰਗ ਦੇ ਅੰਤ ਵਿੱਚ ਇੱਕ ਨਿਊਲਾਈਨ ਚਰੈਕਟਰ (\n) ਛੱਡਿਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇਹ ਫਾਈਲ ਦੀ ਆਖਰੀ ਲਾਈਨ ਵਿੱਚ ਸਿਰਫ਼ ਉਦੋਂ ਹੀ ਨਹੀਂ ਛੱਡਿਆ ਜਾਂਦਾ ਜਦੋਂ ਫਾਈਲ ਨਿਊਲਾਈਨ 'ਤੇ ਖਤਮ ਨਾ ਹੁੰਦੀ ਹੋਵੇ। ਇਸ ਨਾਲ ਵਾਪਸ ਕੀਤੀ ਕੀਮਤ ਸਪਸ਼ਟ ਹੋ ਜਾਂਦੀ ਹੈ; ਜੇ f.readline() ਖਾਲੀ ਸਟਰਿੰਗ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਤਾਂ ਫਾਈਲ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚ ਗਿਆ ਹੈ, ਜਦਕਿ ਇੱਕ ਖਾਲੀ ਲਾਈਨ '\n' ਦੁਆਰਾ ਦਰਸਾਈ ਜਾਂਦੀ ਹੈ, ਜੋ ਸਿਰਫ਼ ਇੱਕ ਨਿਊਲਾਈਨ ਵਾਲੀ ਸਟਰਿੰਗ ਹੈ।

>>> f.readline()
'This is the first line of the file.\n'
>>> f.readline()
'Second line of the file\n'
>>> f.readline()
''

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

>>> for line in f:
...     print(line, end='')
...
This is the first line of the file.
Second line of the file

ਜੇ ਤੁਸੀਂ ਫਾਈਲ ਦੀਆਂ ਸਾਰੀਆਂ ਲਾਈਨਾਂ ਨੂੰ ਇੱਕ list ਵਿੱਚ ਪੜ੍ਹਨਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਤੁਸੀਂ list(f) ਜਾਂ f.readlines() ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ।

f.write(string) string ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਫਾਈਲ ਵਿੱਚ ਲਿਖਦਾ ਹੈ ਅਤੇ ਲਿਖੇ ਗਏ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ।

>>> f.write('This is a test\n')
15

ਹੋਰ ਕਿਸਮਾਂ ਦੀਆਂ ਵਸਤੂਆਂ ਨੂੰ ਲਿਖਣ ਤੋਂ ਪਹਿਲਾਂ ਸਟ੍ਰਿੰਗ (text mode ਵਿੱਚ) ਜਾਂ bytes ਆਬਜੈਕਟ (binary mode ਵਿੱਚ) ਵਿੱਚ ਬਦਲਣਾ ਲਾਜ਼ਮੀ ਹੈ:

>>> value = ('the answer', 42)
>>> s = str(value)  # convert the tuple to string
>>> f.write(s)
18

f.tell() ਇੱਕ ਪੂਰਨ ਅੰਕ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ ਫਾਈਲ ਵਿੱਚ ਫਾਈਲ ਆਬਜੈਕਟ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਦਰਸਾਉਂਦਾ ਹੈ। Binary mode ਵਿੱਚ ਇਹ ਫਾਈਲ ਦੇ ਸ਼ੁਰੂ ਤੋਂ bytes ਦੀ ਗਿਣਤੀ ਵਜੋਂ ਹੁੰਦੀ ਹੈ, ਜਦਕਿ text mode ਵਿੱਚ ਇਹ ਇੱਕ ਅਪਾਰਦਰਸ਼ੀ ਸੰਖਿਆ ਹੁੰਦੀ ਹੈ।

ਫਾਈਲ ਆਬਜੈਕਟ ਦੀ ਸਥਿਤੀ ਬਦਲਣ ਲਈ, f.seek(offset, whence) ਵਰਤੋ। ਸਥਿਤੀ offset ਨੂੰ ਇੱਕ ਸੰਦਰਭ ਬਿੰਦੂ ਨਾਲ ਜੋੜ ਕੇ ਗਣਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ; ਸੰਦਰਭ ਬਿੰਦੂ whence ਆਰਗੂਮੈਂਟ ਦੁਆਰਾ ਚੁਣਿਆ ਜਾਂਦਾ ਹੈ। whence ਦਾ ਮੁੱਲ 0 ਫਾਈਲ ਦੀ ਸ਼ੁਰੂਆਤ ਤੋਂ ਮਾਪਦਾ ਹੈ, 1 ਮੌਜੂਦਾ ਫਾਈਲ ਸਥਿਤੀ ਵਰਤਦਾ ਹੈ, ਅਤੇ 2 ਫਾਈਲ ਦੇ ਅੰਤ ਨੂੰ ਰੈਫਰੈਂਸ ਪੁਆਇੰਟ ਵਜੋਂ ਵਰਤਦਾ ਹੈ। whence ਨੂੰ ਛੱਡਿਆ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਇਹ ਡਿਫੌਲਟ ਤੌਰ 'ਤੇ 0 ਰਹਿੰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਫਾਈਲ ਦੀ ਸ਼ੁਰੂਆਤ ਰੈਫਰੈਂਸ ਪੁਆਇੰਟ ਵਜੋਂ ਵਰਤੀ ਜਾਂਦੀ ਹੈ।

>>> f = open('workfile', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5)      # Go to the 6th byte in the file
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2)  # Go to the 3rd byte before the end
13
>>> f.read(1)
b'd'

Text ਫਾਈਲਾਂ ਵਿੱਚ (ਜੋ mode string ਵਿੱਚ b ਤੋਂ ਬਿਨਾਂ ਖੋਲ੍ਹੀਆਂ ਜਾਂਦੀਆਂ ਹਨ), ਕੇਵਲ ਫਾਈਲ ਦੇ ਸ਼ੁਰੂ ਦੇ ਸਬੰਧ ਵਿੱਚ seek ਕਰਨ ਦੀ ਆਗਿਆ ਹੁੰਦੀ ਹੈ (ਅਪਵਾਦ seek(0, 2) ਨਾਲ ਫਾਈਲ ਦੇ ਅੰਤ ਤੱਕ ਜਾਣਾ ਹੈ)। ਵੈਧ offset ਮੁੱਲ ਕੇਵਲ ਉਹੀ ਹਨ ਜੋ f.tell() ਵਾਪਸ ਕਰਦਾ ਹੈ ਜਾਂ ਸ਼ੂਨ੍ਯ। ਕੋਈ ਹੋਰ offset ਮੁੱਲ ਅਣਪਰਿਭਾਸ਼ਿਤ ਵਿਵਹਾਰ ਪੈਦਾ ਕਰਦਾ ਹੈ।

ਫਾਈਲ ਆਬਜੈਕਟਾਂ ਵਿੱਚ ਕੁਝ ਵਾਧੂ ਵਿਧੀਆਂ ਵੀ ਹੁੰਦੀਆਂ ਹਨ, ਜਿਵੇਂ isatty() ਅਤੇ truncate(), ਜਿਨ੍ਹਾਂ ਦੀ ਵਰਤੋਂ ਘੱਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਫਾਈਲ ਆਬਜੈਕਟਾਂ ਬਾਰੇ ਪੂਰੀ ਜਾਣਕਾਰੀ ਲਈ Library Reference ਵੇਖੋ।

7.2.2. json ਨਾਲ ਸੰਰਚਿਤ ਡਾਟਾ ਸੰਭਾਲਣਾ

ਸਟ੍ਰਿੰਗਾਂ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਫਾਈਲ ਵਿੱਚ ਲਿਖਿਆ ਅਤੇ ਫਾਈਲ ਤੋਂ ਪੜ੍ਹਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਸੰਖਿਆਵਾਂ ਲਈ ਕੁਝ ਵੱਧ ਮਿਹਨਤ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਕਿਉਂਕਿ read() ਵਿਧੀ ਕੇਵਲ ਸਟ੍ਰਿੰਗਾਂ ਵਾਪਸ ਕਰਦੀ ਹੈ, ਜਿਨ੍ਹਾਂ ਨੂੰ int() ਵਰਗੇ ਫੰਕਸ਼ਨ ਵਿੱਚ ਪਾਸ ਕਰਨਾ ਪੈਂਦਾ ਹੈ, ਜੋ '123' ਵਰਗੀ ਸਟ੍ਰਿੰਗ ਲੈ ਕੇ ਉਸਦਾ ਸੰਖਿਆਤਮਕ ਮੁੱਲ 123 ਵਾਪਸ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਤੁਸੀਂ nested lists ਅਤੇ dictionaries ਵਰਗੇ ਹੋਰ ਜਟਿਲ ਡਾਟਾ ਕਿਸਮਾਂ ਨੂੰ ਸੰਭਾਲਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਹੱਥੋਂ parsing ਅਤੇ serializing ਕਰਨਾ ਮੁਸ਼ਕਲ ਹੋ ਜਾਂਦਾ ਹੈ।

ਵਰਤੋਂਕਾਰਾਂ ਨੂੰ ਜਟਿਲ ਡਾਟਾ ਕਿਸਮਾਂ ਨੂੰ ਫਾਈਲਾਂ ਵਿੱਚ ਸੇਵ ਕਰਨ ਲਈ ਲਗਾਤਾਰ ਕੋਡ ਲਿਖਣ ਅਤੇ debug ਕਰਨ ਦੀ ਬਜਾਏ, Python ਤੁਹਾਨੂੰ ਪ੍ਰਸਿੱਧ ਡਾਟਾ ਅਦਾਨ-ਪ੍ਰਦਾਨ ਫਾਰਮੈਟ JSON (JavaScript Object Notation) ਵਰਤਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। json ਨਾਮ ਦਾ ਮਿਆਰੀ module Python ਡਾਟਾ hierarchies ਨੂੰ ਲੈ ਕੇ ਉਹਨਾਂ ਨੂੰ string ਰੂਪ ਵਿੱਚ ਬਦਲ ਸਕਦਾ ਹੈ; ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ serializing ਕਿਹਾ ਜਾਂਦਾ ਹੈ। string representation ਤੋਂ ਡਾਟਾ ਨੂੰ ਮੁੜ ਬਣਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ deserializing ਕਿਹਾ ਜਾਂਦਾ ਹੈ। Serializing ਅਤੇ deserializing ਦੇ ਦਰਮਿਆਨ, object ਨੂੰ ਦਰਸਾਉਂਦੀ string ਕਿਸੇ ਫਾਈਲ ਜਾਂ ਡਾਟਾ ਵਿੱਚ store ਕੀਤੀ ਗਈ ਹੋ ਸਕਦੀ ਹੈ, ਜਾਂ network connection ਰਾਹੀਂ ਕਿਸੇ ਦੂਰ ਦੀ ਮਸ਼ੀਨ ਨੂੰ ਭੇਜੀ ਗਈ ਹੋ ਸਕਦੀ ਹੈ।

Note

JSON ਫਾਰਮੈਟ ਆਧੁਨਿਕ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੁਆਰਾ ਡਾਟਾ ਅਦਾਨ-ਪ੍ਰਦਾਨ ਲਈ ਆਮ ਤੌਰ 'ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਬਹੁਤ ਸਾਰੇ ਪ੍ਰੋਗਰਾਮਰ ਪਹਿਲਾਂ ਹੀ ਇਸ ਨਾਲ ਜਾਣੂ ਹਨ, ਜਿਸ ਕਾਰਨ ਇਹ interoperability ਲਈ ਇੱਕ ਵਧੀਆ ਚੋਣ ਬਣ ਜਾਂਦਾ ਹੈ।

ਜੇ ਤੁਹਾਡੇ ਕੋਲ x ਨਾਮ ਦਾ ਕੋਈ ਆਬਜੈਕਟ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਇੱਕ ਸਧਾਰਣ ਕੋਡ ਲਾਈਨ ਨਾਲ ਉਸਦੀ JSON ਸਟ੍ਰਿੰਗ representation ਵੇਖ ਸਕਦੇ ਹੋ:

>>> import json
>>> x = [1, 'simple', 'list']
>>> json.dumps(x)
'[1, "simple", "list"]'

dumps() ਫੰਕਸ਼ਨ ਦਾ ਇੱਕ ਹੋਰ ਰੂਪ, ਜਿਸਨੂੰ dump() ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਸਿਰਫ਼ ਆਬਜੈਕਟ ਨੂੰ ਇੱਕ text file ਵਿੱਚ ਸੀਰੀਅਲਾਈਜ਼ ਕਰਦਾ ਹੈ। ਇਸ ਲਈ ਜੇ f ਲਿਖਣ ਲਈ ਖੋਲ੍ਹੀ ਗਈ ਇੱਕ text file ਆਬਜੈਕਟ ਹੈ, ਤਾਂ ਅਸੀਂ ਇਹ ਕਰ ਸਕਦੇ ਹਾਂ:

json.dump(x, f)

ਆਬਜੈਕਟ ਨੂੰ ਮੁੜ decode ਕਰਨ ਲਈ, ਜੇ f ਪੜ੍ਹਨ ਲਈ ਖੋਲ੍ਹਿਆ ਗਿਆ ਇੱਕ binary file ਜਾਂ text file ਆਬਜੈਕਟ ਹੈ:

x = json.load(f)

Note

JSON ਫਾਈਲਾਂ ਨੂੰ UTF-8 ਵਿੱਚ ਏਨਕੋਡ ਕੀਤਾ ਜਾਣਾ ਲਾਜ਼ਮੀ ਹੈ, ਜੋ text files ਲਈ ਡਿਫੌਲਟ ਏਨਕੋਡਿੰਗ ਹੈ।

ਇਹ ਸਧਾਰਣ serialization ਤਕਨੀਕ lists ਅਤੇ dictionaries ਨੂੰ ਸੰਭਾਲ ਸਕਦੀ ਹੈ, ਪਰ JSON ਵਿੱਚ ਮਨਮਾਨੇ class instances ਨੂੰ serialize ਕਰਨ ਲਈ ਕੁਝ ਵਾਧੂ ਮਿਹਨਤ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। json ਮੌਡਿਊਲ ਦੇ ਹਵਾਲਾ ਦਸਤਾਵੇਜ਼ ਵਿੱਚ ਇਸਦੀ ਵਿਆਖਿਆ ਮੌਜੂਦ ਹੈ।

See also

pickle - pickle ਮੌਡਿਊਲ

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