ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ

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

ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ
A abs() aiter() all() anext() any() ascii() B bin() bool() breakpoint() bytearray() bytes() C callable() chr() classmethod() compile() complex() D delattr() dict() dir() divmod()	E enumerate() eval() exec() F filter() float() format() frozendict() frozenset() G getattr() globals() H hasattr() hash() help() hex() I id() input() int() isinstance() issubclass() iter()	L len() list() locals() M map() max() memoryview() min() N next() O object() oct() open() ord() P pow() print() property()	R range() repr() reversed() round() S set() setattr() sentinel() slice() sorted() staticmethod() str() sum() super() T tuple() type() V vars() Z zip() _ __import__()

abs(number, /)

ਕਿਸੇ ਸੰਖਿਆ ਦਾ ਪਰਮ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਆਰਗੂਮੈਂਟ ਇੱਕ ਪੂਰਨ ਸੰਖਿਆ, ਫਲੋਟਿੰਗ-ਪੌਇੰਟ ਸੰਖਿਆ ਜਾਂ __abs__() ਨੂੰ ਲਾਗੂ ਕਰਨ ਵਾਲੀ ਵਸਤੂ ਹੋ ਸਕਦੀ ਹੈ। ਜੇ ਆਰਗੂਮੈਂਟ ਇੱਕ complex ਸੰਖਿਆ ਹੈ, ਤਾਂ ਇਸ ਦਾ ਪਰਿਮਾਣ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

aiter(async_iterable, /)

ਇੱਕ asynchronous iterable ਲਈ asynchronous iterator ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਹ x.__aiter__() ਨੂੰ ਕਾਲ ਕਰਨ ਦੇ ਬਰਾਬਰ ਹੈ।

ਨੋਟ: iter() ਤੋਂ ਵੱਖਰਾ, aiter() ਦਾ 2-ਆਰਗੂਮੈਂਟ ਰੂਪ ਨਹੀਂ ਹੁੰਦਾ।

Added in version 3.10.

all(iterable, /)

ਜੇ iterable ਦੇ ਸਾਰੇ ਤੱਤ true ਹਨ (ਜਾਂ iterable ਖਾਲੀ ਹੈ), ਤਾਂ True ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਹ ਇਸ ਦੇ ਬਰਾਬਰ ਹੈ:

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

awaitable anext(async_iterator, /)

awaitable anext(async_iterator, default, /)

ਉਡੀਕ ਕੀਤੇ ਜਾਣ 'ਤੇ, ਦਿੱਤੇ ਗਏ asynchronous iterator ਵਿੱਚੋਂ ਅਗਲੀ ਆਈਟਮ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜਾਂ ਜੇ ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ ਤਾਂ default ਵਾਪਸ ਕਰਦਾ ਹੈ ਅਤੇ ਜੇ ਇਟਰੇਟਰ exhausted ਹੋ ਗਿਆ ਹੋਵੇ।

ਇਹ next() ਬਿਲਟ-ਇਨ ਦਾ asynchronous ਰੂਪ ਹੈ ਅਤੇ ਇਸੇ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ।

ਇਹ async_iterator ਦੀ __anext__() ਮੈਥਡ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ awaitable ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਸਨੂੰ await ਕਰਨ 'ਤੇ iterator ਦਾ ਅਗਲਾ ਮੁੱਲ ਪ੍ਰਾਪਤ ਹੁੰਦਾ ਹੈ। ਜੇ default ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ ਤਾਂ iterator ਦੇ ਸਮਾਪਤ ਹੋਣ ਤੇ ਉਹੀ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਨਹੀਂ ਤਾਂ StopAsyncIteration exception ਉਠਾਈ ਜਾਂਦੀ ਹੈ।

Added in version 3.10.

any(iterable, /)

ਜੇ iterable ਦਾ ਕੋਈ ਵੀ ਤੱਤ true ਹੋਵੇ ਤਾਂ True ਵਾਪਸ ਕਰਦਾ ਹੈ। ਜੇ iterable ਖਾਲੀ ਹੋਵੇ ਤਾਂ False ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਹ ਇਸ ਦੇ ਬਰਾਬਰ ਹੈ:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

ascii(object, /)

repr() ਦੀ ਤਰ੍ਹਾਂ, ਕਿਸੇ ਵਸਤੂ ਦੀ ਪ੍ਰਿੰਟ ਕੀਤੀ ਜਾ ਸਕਣ ਵਾਲੀ ਨੁਮਾਇੰਦਗੀ ਵਾਲੀ ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਪਰ repr() ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੀ ਗਈ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਮੌਜੂਦ non-ASCII ਅੱਖਰਾਂ ਨੂੰ \x, \u ਜਾਂ \U escape sequence ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦਰਸਾਉਂਦਾ ਹੈ। ਇਸ ਨਾਲ Python 2 ਦੇ repr() ਵਰਗੀ ਸਟ੍ਰਿੰਗ ਬਣਦੀ ਹੈ।

bin(integer, /)

ਇੱਕ ਪੂਰਨ ਸੰਖਿਆ ਨੂੰ "0b" ਪ੍ਰੀਫਿਕਸ ਵਾਲੀ binary ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਬਦਲਦਾ ਹੈ। ਨਤੀਜਾ ਇੱਕ ਵੈਧ Python expression ਹੁੰਦਾ ਹੈ। ਜੇ integer Python int ਵਸਤੂ ਨਹੀਂ ਹੈ, ਤਾਂ ਉਸ ਵਿੱਚ __index__() ਮੈਥਡ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਇੱਕ ਪੂਰਨ ਸੰਖਿਆ ਵਾਪਸ ਕਰੇ। ਕੁਝ ਉਦਾਹਰਨਾਂ:

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

ਜੇ "0b" ਪ੍ਰੀਫਿਕਸ ਚਾਹੀਦਾ ਹੋਵੇ ਜਾਂ ਨਾ ਚਾਹੀਦਾ ਹੋਵੇ, ਤਾਂ ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਕਿਸੇ ਵੀ ਤਰੀਕੇ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।

>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

ਨਕਾਰਾਤਮਕ ਮੁੱਲਾਂ ਨੂੰ two's complement ਰੂਪ ਵਿੱਚ ਦਰਸਾਉਣ ਲਈ enum.bin() ਵੀ ਦੇਖੋ।

ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ format() ਵੀ ਵੇਖੋ।

class bool(object=False, /)

ਇੱਕ Boolean ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਅਰਥਾਤ True ਜਾਂ False ਵਿੱਚੋਂ ਇੱਕ। ਆਰਗੂਮੈਂਟ ਨੂੰ ਮਿਆਰੀ truth testing procedure ਅਨੁਸਾਰ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ। ਜੇ ਆਰਗੂਮੈਂਟ false ਹੋਵੇ ਜਾਂ ਦਿੱਤਾ ਨਾ ਗਿਆ ਹੋਵੇ, ਤਾਂ False ਵਾਪਸ ਹੁੰਦਾ ਹੈ; ਨਹੀਂ ਤਾਂ True ਵਾਪਸ ਹੁੰਦਾ ਹੈ। bool ਕਲਾਸ int ਦੀ ਉਪ-ਕਲਾਸ ਹੈ (ਵੇਖੋ Numeric Types --- int, float, complex)। ਇਸ ਦੀ ਹੋਰ ਉਪ-ਕਲਾਸ ਨਹੀਂ ਬਣਾਈ ਜਾ ਸਕਦੀ। ਇਸ ਦੇ ਕੇਵਲ ਦੋ ਹੀ ਇੰਸਟੈਂਸ ਹਨ: False ਅਤੇ True (ਵੇਖੋ Boolean Type - bool)।

Changed in version 3.7: ਹੁਣ ਇਹ ਪੈਰਾਮੀਟਰ ਕੇਵਲ positional ਰੂਪ ਵਿੱਚ ਹੀ ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ।

breakpoint(*args, **kws)

ਇਹ ਫੰਕਸ਼ਨ ਤੁਹਾਨੂੰ ਉਸ ਥਾਂ debugger ਵਿੱਚ ਲੈ ਜਾਂਦਾ ਹੈ ਜਿੱਥੇ ਇਸਨੂੰ ਕਾਲ ਕੀਤਾ ਗਿਆ ਹੋਵੇ। ਖਾਸ ਤੌਰ 'ਤੇ, ਇਹ args ਅਤੇ kws ਨੂੰ ਸਿੱਧਾ sys.breakpointhook() ਨੂੰ ਭੇਜਦਾ ਹੈ। ਮੂਲ ਰੂਪ ਵਿੱਚ sys.breakpointhook() ਬਿਨਾਂ ਕਿਸੇ ਆਰਗੂਮੈਂਟ ਦੇ pdb.set_trace() ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ। ਇਸ ਕਰਕੇ ਤੁਹਾਨੂੰ pdb ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ import ਕਰਨ ਜਾਂ debugger ਵਿੱਚ ਜਾਣ ਲਈ ਵਾਧੂ ਕੋਡ ਲਿਖਣ ਦੀ ਲੋੜ ਨਹੀਂ ਪੈਂਦੀ। ਹਾਲਾਂਕਿ, sys.breakpointhook() ਨੂੰ ਕਿਸੇ ਹੋਰ ਫੰਕਸ਼ਨ ਨਾਲ ਵੀ ਸੈੱਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ breakpoint() ਆਪਣੇ ਆਪ ਉਸਨੂੰ ਕਾਲ ਕਰੇਗਾ, ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਆਪਣੀ ਪਸੰਦ ਦੇ debugger ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਜੇ sys.breakpointhook() ਉਪਲਬਧ ਨਾ ਹੋਵੇ, ਤਾਂ ਇਹ ਫੰਕਸ਼ਨ RuntimeError ਉਠਾਏਗਾ।

ਮੂਲ ਰੂਪ ਵਿੱਚ breakpoint() ਦਾ ਵਿਹਾਰ PYTHONBREAKPOINT environment variable ਰਾਹੀਂ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਵਰਤੋਂ ਸੰਬੰਧੀ ਵੇਰਵਿਆਂ ਲਈ sys.breakpointhook() ਵੇਖੋ।

ਧਿਆਨ ਰਹੇ ਕਿ ਜੇ sys.breakpointhook() ਨੂੰ ਬਦਲ ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ ਤਾਂ ਇਸ ਦੀ ਗਾਰੰਟੀ ਨਹੀਂ ਹੈ।

breakpointhook ਆਰਗੂਮੈਂਟ ਨਾਲ ਇੱਕ auditing event builtins.breakpoint ਉਠਾਇਆ ਜਾਂਦਾ ਹੈ।

Added in version 3.7.

class bytearray(source=b'')

class bytearray(source, encoding, errors='strict')

ਬਾਈਟਾਂ ਦਾ ਇੱਕ ਨਵਾਂ array ਵਾਪਸ ਕਰਦਾ ਹੈ। bytearray class 0 <= x < 256 ਦੀ ਸੀਮਾ ਵਿੱਚ integers ਦੀ ਇੱਕ mutable sequence ਹੈ। ਇਸ ਵਿੱਚ mutable sequences ਦੇ ਜ਼ਿਆਦਾਤਰ ਆਮ methods ਹਨ, ਜਿਨ੍ਹਾਂ ਦਾ ਵੇਰਵਾ Mutable Sequence Types ਵਿੱਚ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਨਾਲ ਹੀ bytes type ਦੇ ਬਹੁਤ ਸਾਰੇ methods ਵੀ ਹਨ, ਵੇਖੇ Bytes and Bytearray Operations।

ਵਿਕਲਪਿਕ source ਪੈਰਾਮੀਟਰ ਦੀ ਵਰਤੋਂ ਐਰੇ ਨੂੰ ਕਈ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਨਾਲ ਸ਼ੁਰੂਆਤੀ ਮੁੱਲ ਦੇਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ:

• ਜੇ ਇਹ ਇੱਕ string ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ encoding (ਅਤੇ ਵਿਕਲਪਿਕ ਤੌਰ 'ਤੇ errors) ਪੈਰਾਮੀਟਰ ਵੀ ਦੇਣੇ ਪੈਣਗੇ; ਫਿਰ bytearray() str.encode() ਦੀ ਵਰਤੋਂ ਕਰਕੇ string ਨੂੰ bytes ਵਿੱਚ ਬਦਲਦਾ ਹੈ।

• ਜੇ ਇਹ ਇੱਕ integer ਹੈ, ਤਾਂ ਐਰੇ ਦਾ ਆਕਾਰ ਉਸਦੇ ਬਰਾਬਰ ਹੋਵੇਗਾ ਅਤੇ ਇਸ ਨੂੰ null bytes ਨਾਲ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾਵੇਗਾ।

• ਜੇ ਇਹ buffer interface ਦੇ ਅਨੁਕੂਲ ਕੋਈ ਆਬਜੈਕਟ ਹੈ, ਤਾਂ ਉਸ ਆਬਜੈਕਟ ਦਾ read-only buffer bytes ਐਰੇ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਵੇਗਾ।

• ਜੇ ਇਹ ਇੱਕ iterable ਹੈ, ਤਾਂ ਇਹ 0 <= x < 256 ਦੀ ਸੀਮਾ ਵਾਲੇ ਪੂਰਨ ਅੰਕਾਂ ਦੀ iterable ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਜੋ ਐਰੇ ਦੀ ਸ਼ੁਰੂਆਤੀ ਸਮੱਗਰੀ ਵਜੋਂ ਵਰਤੇ ਜਾਂਦੇ ਹਨ।

ਬਿਨਾਂ ਕਿਸੇ ਆਰਗੂਮੈਂਟ ਦੇ, ਆਕਾਰ 0 ਵਾਲਾ ਐਰੇ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ।

ਇਹ ਵੀ ਵੇਖੋ Binary Sequence Types --- bytes, bytearray, memoryview ਅਤੇ Bytearray Objects।

class bytes(source=b'')

class bytes(source, encoding, errors='strict')

ਇੱਕ ਨਵਾਂ "bytes" ਆਬਜੈਕਟ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ 0 <= x < 256 ਸੀਮਾ ਦੇ ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਇੱਕ ਅਪਰਿਵਰਤਨਸ਼ੀਲ ਲੜੀ ਹੈ। bytes, bytearray ਦਾ ਅਪਰਿਵਰਤਨਸ਼ੀਲ ਰੂਪ ਹੈ — ਇਸ ਵਿੱਚ ਉਹੀ non-mutating ਮੈਥਡ ਅਤੇ ਉਹੀ indexing ਅਤੇ slicing ਵਿਹਾਰ ਹੁੰਦਾ ਹੈ।

ਇਸ ਲਈ constructor arguments ਨੂੰ bytearray() ਵਾਂਗ ਹੀ ਸਮਝਿਆ ਜਾਂਦਾ ਹੈ।

Bytes ਆਬਜੈਕਟ literals ਦੀ ਵਰਤੋਂ ਨਾਲ ਵੀ ਬਣਾਏ ਜਾ ਸਕਦੇ ਹਨ, ਵੇਖੋ String and Bytes literals।

ਇਸ ਨਾਲ ਸੰਬੰਧਿਤ Binary Sequence Types --- bytes, bytearray, memoryview, Bytes Objects ਅਤੇ Bytes and Bytearray Operations ਵੀ ਵੇਖੋ।

callable(object, /)

ਜੇ object argument callable ਲੱਗਦਾ ਹੋਵੇ ਤਾਂ True ਵਾਪਸ ਕਰਦਾ ਹੈ, ਨਹੀਂ ਤਾਂ False। ਜੇ ਇਹ True ਵਾਪਸ ਕਰੇ, ਤਾਂ ਵੀ ਸੰਭਵ ਹੈ ਕਿ ਕਾਲ ਅਸਫਲ ਹੋ ਜਾਵੇ, ਪਰ ਜੇ False ਹੋਵੇ ਤਾਂ object ਨੂੰ ਕਾਲ ਕਰਨਾ ਕਦੇ ਵੀ ਸਫਲ ਨਹੀਂ ਹੋਵੇਗਾ। ਧਿਆਨ ਰਹੇ ਕਿ classes callable ਹੁੰਦੀਆਂ ਹਨ (class ਨੂੰ ਕਾਲ ਕਰਨ ਨਾਲ ਨਵਾਂ instance ਬਣਦਾ ਹੈ); instances callable ਤਦ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਉਨ੍ਹਾਂ ਦੀ class ਵਿੱਚ __call__() ਮੈਥਡ ਹੋਵੇ।

Added in version 3.2: ਇਹ ਫੰਕਸ਼ਨ ਪਹਿਲਾਂ Python 3.0 ਵਿੱਚ ਹਟਾਇਆ ਗਿਆ ਸੀ ਅਤੇ ਬਾਅਦ ਵਿੱਚ Python 3.2 ਵਿੱਚ ਮੁੜ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ।

chr(codepoint, /)

ਨਿਰਧਾਰਤ Unicode code point ਵਾਲੇ ਅੱਖਰ ਨੂੰ ਦਰਸਾਉਂਦੀ string ਵਾਪਸ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, chr(97) string 'a' ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜਦਕਿ chr(8364) string '€' ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਹ ord() ਦਾ ਉਲਟ ਹੈ।

ਅਰਗੂਮੈਂਟ ਲਈ ਵੈਧ ਸੀਮਾ 0 ਤੋਂ 1,114,111 (ਹੈਕਸਾਡੇਸਿਮਲ-16 ਵਿੱਚ 0x10FFFF) ਤੱਕ ਹੈ। ਜੇ ਇਹ ਸੀਮਾ ਤੋਂ ਬਾਹਰ ਹੋਵੇ ਤਾਂ ValueError ਉਠਾਇਆ ਜਾਵੇਗਾ।

@classmethod

ਇੱਕ ਮੈਥਡ ਨੂੰ class method ਵਿੱਚ ਬਦਲੋ।

ਇੱਕ class method ਨੂੰ class ਪਹਿਲੇ ਅਪਰੋਕਸ਼ argument ਵਜੋਂ ਮਿਲਦੀ ਹੈ, ਬਿਲਕੁਲ ਉਸੇ ਤਰ੍ਹਾਂ ਜਿਵੇਂ instance method ਨੂੰ instance ਮਿਲਦਾ ਹੈ। class method ਘੋਸ਼ਿਤ ਕਰਨ ਲਈ ਇਹ ਤਰੀਕਾ ਵਰਤੋ:

class C:
    @classmethod
    def f(cls, arg1, arg2): ...

@classmethod ਰੂਪ ਇੱਕ decorator ਫੰਕਸ਼ਨ ਹੈ — ਵੇਰਵਿਆਂ ਲਈ Function definitions ਵੇਖੋ।

Class method ਨੂੰ class (ਜਿਵੇਂ C.f()) ਜਾਂ instance (ਜਿਵੇਂ C().f()) ਦੋਹਾਂ ਉੱਤੇ ਕਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। instance ਨੂੰ ਉਸਦੀ class ਤੋਂ ਇਲਾਵਾ ਅਣਡਿੱਠਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਜੇ derived class ਲਈ class method ਕਾਲ ਕੀਤਾ ਜਾਵੇ, ਤਾਂ derived class ਆਬਜੈਕਟ ਪਹਿਲੇ ਅਪਰੋਕਸ਼ argument ਵਜੋਂ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ।

Class methods, C++ ਜਾਂ Java ਦੇ static methods ਤੋਂ ਵੱਖ ਹਨ। ਜੇ ਤੁਹਾਨੂੰ ਉਹ ਚਾਹੀਦੇ ਹਨ ਤਾਂ ਇਸ ਭਾਗ ਵਿੱਚ staticmethod() ਵੇਖੋ। Class methods ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ The standard type hierarchy ਵੇਖੋ।

Changed in version 3.9: ਹੁਣ class methods ਹੋਰ descriptors ਜਿਵੇਂ property() ਨੂੰ wrap ਕਰ ਸਕਦੇ ਹਨ।

Changed in version 3.10: ਹੁਣ class methods ਮੈਥਡ attributes (__module__, __name__, __qualname__, __doc__ ਅਤੇ __annotations__) ਨੂੰ inherit ਕਰਦੇ ਹਨ ਅਤੇ ਇੱਕ ਨਵਾਂ __wrapped__ attribute ਵੀ ਰੱਖਦੇ ਹਨ।

Deprecated since version 3.11, removed in version 3.13: ਹੁਣ class methods ਹੋਰ descriptors ਜਿਵੇਂ property() ਨੂੰ wrap ਨਹੀਂ ਕਰ ਸਕਦੇ।

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1, *, module=None)

source ਨੂੰ ਕੋਡ ਜਾਂ AST ਆਬਜੈਕਟ ਵਿੱਚ ਕੰਪਾਇਲ ਕਰੋ। ਕੋਡ ਆਬਜੈਕਟਾਂ ਨੂੰ exec() ਜਾਂ eval() ਰਾਹੀਂ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। source ਇੱਕ ਸਧਾਰਣ ਸਟਰਿੰਗ, ਬਾਈਟ ਸਟ੍ਰਿੰਗ ਜਾਂ AST ਆਬਜੈਕਟ ਹੋ ਸਕਦਾ ਹੈ। AST ਆਬਜੈਕਟਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਬਾਰੇ ਜਾਣਕਾਰੀ ਲਈ ast ਮੋਡੀਊਲ ਦਾ ਦਸਤਾਵੇਜ਼ ਵੇਖੋ।

filename ਆਰਗੂਮੈਂਟ ਉਸ ਫਾਈਲ ਦਾ ਨਾਮ ਦਿੰਦਾ ਹੈ ਜਿਸ ਤੋਂ ਕੋਡ ਪੜ੍ਹਿਆ ਗਿਆ ਸੀ; ਜੇ ਕੋਡ ਫਾਈਲ ਤੋਂ ਨਹੀਂ ਪੜ੍ਹਿਆ ਗਿਆ ਤਾਂ ਕੋਈ ਪਛਾਣਯੋਗ ਮੁੱਲ ਦਿਓ (ਆਮ ਤੌਰ 'ਤੇ '<string>' ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ)।

mode ਦਲੀਲ ਇਹ ਨਿਰਧਾਰਤ ਕਰਦੀ ਹੈ ਕਿ ਕਿਸ ਤਰ੍ਹਾਂ ਦਾ ਕੋਡ ਕੰਪਾਇਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ; ਇਹ 'exec' ਹੋ ਸਕਦੀ ਹੈ ਜੇ source ਬਿਆਨਾਂ ਦੀ ਇੱਕ ਲੜੀ ਹੋਵੇ, 'eval' ਜੇ ਇਹ ਇੱਕ ਇਕੱਲਾ ਐਕਸਪ੍ਰੈਸ਼ਨ ਹੋਵੇ, ਜਾਂ 'single' ਜੇ ਇਹ ਇੱਕ ਇਕੱਲਾ ਇੰਟਰਐਕਟਿਵ ਬਿਆਨ ਹੋਵੇ (ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਉਹ ਐਕਸਪ੍ਰੈਸ਼ਨ ਬਿਆਨ ਜੋ None ਤੋਂ ਇਲਾਵਾ ਕਿਸੇ ਹੋਰ ਮੁੱਲ ਨੂੰ ਮੁਲਾਂਕਣ ਕਰਦੇ ਹਨ, ਛਾਪੇ ਜਾਣਗੇ)।

ਵਿਕਲਪਿਕ arguments flags ਅਤੇ dont_inherit ਇਹ ਨਿਯੰਤਰਿਤ ਕਰਦੇ ਹਨ ਕਿ ਕਿਹੜੇ compiler options ਚਾਲੂ ਕੀਤੇ ਜਾਣ ਅਤੇ ਕਿਹੜੀਆਂ future features ਦੀ ਆਗਿਆ ਦਿੱਤੀ ਜਾਵੇ। ਜੇ ਦੋਵੇਂ ਮੌਜੂਦ ਨਾ ਹੋਣ (ਜਾਂ ਦੋਵੇਂ ਸਿਫ਼ਰ ਹੋਣ), ਤਾਂ ਕੋਡ ਉਹਨਾਂ ਹੀ flags ਨਾਲ compile ਹੁੰਦਾ ਹੈ ਜੋ compile() ਨੂੰ ਕਾਲ ਕਰਨ ਵਾਲੇ ਕੋਡ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੇ ਹਨ। ਜੇ flags argument ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ ਅਤੇ dont_inherit ਨਾ ਹੋਵੇ (ਜਾਂ ਸਿਫ਼ਰ ਹੋਵੇ), ਤਾਂ flags argument ਦੁਆਰਾ ਨਿਰਧਾਰਤ compiler options ਅਤੇ future statements ਉਹਨਾਂ ਦੇ ਨਾਲ-ਨਾਲ ਵਰਤੇ ਜਾਂਦੇ ਹਨ ਜੋ ਕਿਸੇ ਵੀ ਹਾਲਤ ਵਿੱਚ ਵਰਤੇ ਜਾਣਗੇ। ਜੇ dont_inherit ਇੱਕ ਗੈਰ-ਸਿਫ਼ਰ integer ਹੋਵੇ, ਤਾਂ flags argument ਹੀ ਸਭ ਕੁਝ ਹੈ — ਆਲੇ-ਦੁਆਲੇ ਦੇ ਕੋਡ ਵਿੱਚਲੇ flags (future features ਅਤੇ compiler options) ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਕੰਪਾਈਲਰ ਵਿਕਲਪ ਅਤੇ future ਸਟੇਟਮੈਂਟ ਬਿੱਟਾਂ ਰਾਹੀਂ ਦਰਸਾਏ ਜਾਂਦੇ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ bitwise OR ਨਾਲ ਜੋੜ ਕੇ ਕਈ ਵਿਕਲਪ ਚੁਣੇ ਜਾ ਸਕਦੇ ਹਨ। ਕਿਸੇ future feature ਲਈ ਲੋੜੀਂਦਾ bitfield __future__ ਮੋਡੀਊਲ ਵਿੱਚ ਮੌਜੂਦ _Feature ਦੇ compiler_flag ਐਟ੍ਰਿਬਿਊਟ ਵਿੱਚ ਮਿਲਦਾ ਹੈ। Compiler flags ast ਮੋਡੀਊਲ ਵਿੱਚ PyCF_ ਪ੍ਰੀਫਿਕਸ ਨਾਲ ਉਪਲਬਧ ਹਨ।

optimize ਆਰਗੂਮੈਂਟ ਕੰਪਾਈਲਰ ਦਾ optimization ਪੱਧਰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ; ਡਿਫਾਲਟ ਮੁੱਲ -1 ਇੰਟਰਪ੍ਰੀਟਰ ਦੇ -O ਵਿਕਲਪ ਅਨੁਸਾਰ ਪੱਧਰ ਚੁਣਦਾ ਹੈ। ਸਪਸ਼ਟ ਪੱਧਰ ਹਨ: 0 (ਕੋਈ optimization ਨਹੀਂ; __debug__ ਸਹੀ ਹੈ), 1 (assert ਹਟਾਏ ਜਾਂਦੇ ਹਨ; __debug__ ਗਲਤ ਹੈ), ਜਾਂ 2 (docstring ਵੀ ਹਟਾਏ ਜਾਂਦੇ ਹਨ)।

ਵਿਕਲਪਿਕ ਆਰਗੂਮੈਂਟ module ਮੋਡੀਊਲ ਦਾ ਨਾਮ ਦਰਸਾਉਂਦਾ ਹੈ। ਇਹ ਮੋਡੀਊਲ ਨਾਮ ਦੇ ਆਧਾਰ 'ਤੇ filter syntax warnings ਨੂੰ ਸਪਸ਼ਟ ਕਰਨ ਲਈ ਲੋੜੀਂਦਾ ਹੈ।

ਇਹ ਫੰਕਸ਼ਨ SyntaxError ਉਠਾਉਂਦਾ ਹੈ ਜੇ compile ਕੀਤਾ ਜਾ ਰਿਹਾ source ਵੈਧ ਨਾ ਹੋਵੇ, ਜਿਸ ਵਿੱਚ ਉਹ source ਵੀ ਸ਼ਾਮਲ ਹੈ ਜਿਸ ਵਿੱਚ null character ਹੋਵੇ ਜਾਂ ਜਿਸਨੂੰ decode ਨਾ ਕੀਤਾ ਜਾ ਸਕੇ; ValueError ਜੇ mode ਜਾਂ flags ਵੈਧ ਨਾ ਹੋਣ, ਜਾਂ ਜੇ string source ਵਿੱਚ surrogate characters ਹੋਣ; MemoryError ਜਾਂ RecursionError ਜੇ source parse ਜਾਂ compile ਕਰਨ ਲਈ ਬਹੁਤ ਗੁੰਝਲਦਾਰ ਹੋਵੇ, ਉਦਾਹਰਨ ਲਈ ਕਈ ਹਜ਼ਾਰ nested operators ਵਾਲਾ expression; ਅਤੇ OverflowError ਜੇ source ਬਹੁਤ ਵੱਡਾ ਹੋਵੇ।

ਜੇ ਤੁਸੀਂ Python ਕੋਡ ਨੂੰ AST ਰੂਪ ਵਿੱਚ ਪਾਰਸ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ast.parse() ਵੇਖੋ।

source ਅਤੇ filename ਆਰਗੂਮੈਂਟਾਂ ਨਾਲ ਇੱਕ auditing event compile ਉਠਾਇਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਇਵੈਂਟ ਅਪਰੋਖ ਕੰਪਾਇਲੇਸ਼ਨ ਦੌਰਾਨ ਵੀ ਉਠ ਸਕਦਾ ਹੈ।

Note

ਜਦੋਂ 'single' ਜਾਂ 'eval' ਮੋਡ ਵਿੱਚ ਬਹੁ-ਲਾਈਨ ਕੋਡ ਵਾਲੀ ਸਟਰਿੰਗ ਕੰਪਾਇਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਇਨਪੁੱਟ ਦਾ ਅੰਤ ਘੱਟੋ-ਘੱਟ ਇੱਕ newline ਅੱਖਰ ਨਾਲ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ code ਮੋਡੀਊਲ ਵਿੱਚ ਅਧੂਰੇ ਅਤੇ ਪੂਰੇ ਸਟੇਟਮੈਂਟਾਂ ਦੀ ਪਛਾਣ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ।

Warning

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

Changed in version 3.2: Windows ਅਤੇ Mac newline ਦੀ ਵਰਤੋਂ ਦੀ ਆਗਿਆ ਦਿੱਤੀ ਗਈ। ਨਾਲ ਹੀ, 'exec' ਮੋਡ ਵਿੱਚ ਇਨਪੁੱਟ ਦਾ newline ਨਾਲ ਖਤਮ ਹੋਣਾ ਹੁਣ ਲਾਜ਼ਮੀ ਨਹੀਂ ਹੈ। optimize ਪੈਰਾਮੀਟਰ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ।

Changed in version 3.5: ਪਹਿਲਾਂ, ਜਦੋਂ source ਵਿੱਚ null bytes ਮਿਲਦੇ ਸਨ ਤਾਂ TypeError ਉਠਾਇਆ ਜਾਂਦਾ ਸੀ।

Changed in version 3.8: ਹੁਣ flags ਵਿੱਚ ast.PyCF_ALLOW_TOP_LEVEL_AWAIT ਦੇ ਕੇ top-level await, async for ਅਤੇ async with ਲਈ ਸਮਰਥਨ ਯੋਗ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

Changed in version 3.12: ਜਦੋਂ source ਵਿੱਚ null bytes ਮਿਲਦੇ ਹਨ, ਤਾਂ ValueError ਦੀ ਬਜਾਏ SyntaxError ਉਠਾਇਆ ਜਾਂਦਾ ਹੈ।

Changed in version 3.15: module ਪੈਰਾਮੀਟਰ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ।

class complex(number=0, /)

class complex(string, /)

class complex(real=0, imag=0)

ਇੱਕ ਸਟਰਿੰਗ ਜਾਂ ਸੰਖਿਆ ਨੂੰ complex ਸੰਖਿਆ ਵਿੱਚ ਬਦਲੋ, ਜਾਂ real ਅਤੇ imaginary ਭਾਗਾਂ ਤੋਂ complex ਸੰਖਿਆ ਬਣਾਓ।

ਉਦਾਹਰਨਾਂ:

>>> complex('+1.23')
(1.23+0j)
>>> complex('-4.5j')
-4.5j
>>> complex('-1.23+4.5j')
(-1.23+4.5j)
>>> complex('\t( -1.23+4.5J )\n')
(-1.23+4.5j)
>>> complex('-Infinity+NaNj')
(-inf+nanj)
>>> complex(1.23)
(1.23+0j)
>>> complex(imag=-4.5)
-4.5j
>>> complex(-1.23, 4.5)
(-1.23+4.5j)

ਜੇ ਦਲੀਲ ਇੱਕ ਸਟ੍ਰਿੰਗ ਹੈ, ਤਾਂ ਇਸ ਵਿੱਚ ਜਾਂ ਤਾਂ ਇੱਕ real ਹਿੱਸਾ (float() ਲਈ ਵਰਤੇ ਗਏ ਫਾਰਮੈਟ ਵਿੱਚ) ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਜਾਂ ਇੱਕ imaginary ਹਿੱਸਾ (ਉਸੇ ਫਾਰਮੈਟ ਵਿੱਚ ਪਰ 'j' ਜਾਂ 'J' suffix ਨਾਲ), ਜਾਂ ਦੋਵੇਂ real ਅਤੇ imaginary ਹਿੱਸੇ (ਇਸ ਸਥਿਤੀ ਵਿੱਚ imaginary ਹਿੱਸੇ ਦਾ ਚਿੰਨ੍ਹ ਲਾਜ਼ਮੀ ਹੈ)। ਸਟ੍ਰਿੰਗ ਵਿਕਲਪਿਕ ਤੌਰ 'ਤੇ ਖਾਲੀ ਥਾਂਵਾਂ ਅਤੇ ਗੋਲ ਬ੍ਰੈਕਟਾਂ '(' ਅਤੇ ')' ਨਾਲ ਘਿਰੀ ਹੋ ਸਕਦੀ ਹੈ, ਜਿਨ੍ਹਾਂ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਸਟ੍ਰਿੰਗ ਵਿੱਚ '+', '-', 'j' ਜਾਂ 'J' suffix ਅਤੇ ਦਸ਼ਮਲਵ ਅੰਕ ਦੇ ਵਿਚਕਾਰ whitespace ਨਹੀਂ ਹੋਣੀ ਚਾਹੀਦੀ। ਉਦਾਹਰਨ ਵਜੋਂ, complex('1+2j') ਠੀਕ ਹੈ, ਪਰ complex('1 + 2j') ValueError exception ਉਠਾਉਂਦਾ ਹੈ। ਹੋਰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ, ਬ੍ਰੈਕਟਾਂ ਅਤੇ ਸ਼ੁਰੂਆਤੀ/ਅੰਤਲੀ whitespace ਹਟਾਉਣ ਤੋਂ ਬਾਅਦ, input ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ grammar ਵਿੱਚ complexvalue ਉਤਪਾਦਨ ਨਿਯਮ ਦੇ ਅਨੁਕੂਲ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ:

complexvalue: floatvalue |
              floatvalue ("j" | "J") |
              floatvalue sign absfloatvalue ("j" | "J")

ਜੇ ਦਲੀਲ ਇੱਕ ਨੰਬਰ ਹੋਵੇ, ਤਾਂ ਕੰਸਟ੍ਰਕਟਰ int ਅਤੇ float ਵਾਂਗ ਸੰਖਿਆਕ ਰੂਪਾਂਤਰਣ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਇੱਕ ਆਮ Python ਆਬਜੈਕਟ x ਲਈ, complex(x) x.__complex__() ਵੱਲ ਡੈਲੀਗੇਟ ਕਰਦਾ ਹੈ। ਜੇ __complex__() ਪਰਿਭਾਸ਼ਿਤ ਨਾ ਹੋਵੇ ਤਾਂ ਇਹ __float__()'ਤੇ ਵਾਪਸ ਆ ਜਾਂਦਾ ਹੈ। ਜੇ __float__() ਪਰਿਭਾਸ਼ਿਤ ਨਾ ਹੋਵੇ ਤਾਂ ਇਹ __index__()'ਤੇ ਵਾਪਸ ਆ ਜਾਂਦਾ ਹੈ।

ਜੇ ਦੋ ਆਰਗੂਮੈਂਟ ਦਿੱਤੇ ਜਾਣ ਜਾਂ keyword arguments ਵਰਤੇ ਜਾਣ, ਤਾਂ ਹਰ ਆਰਗੂਮੈਂਟ ਕਿਸੇ ਵੀ ਸੰਖਿਆਤਮਕ ਕਿਸਮ ਦਾ ਹੋ ਸਕਦਾ ਹੈ (complex ਸਮੇਤ)। ਜੇ ਦੋਵੇਂ ਆਰਗੂਮੈਂਟ real ਸੰਖਿਆਵਾਂ ਹਨ, ਤਾਂ real ਭਾਗ real ਅਤੇ imaginary ਭਾਗ imag ਵਾਲੀ complex ਸੰਖਿਆ ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਜੇ ਦੋਵੇਂ complex ਸੰਖਿਆਵਾਂ ਹਨ, ਤਾਂ real ਭਾਗ real.real-imag.imag ਅਤੇ imaginary ਭਾਗ real.imag+imag.real ਵਾਲੀ complex ਸੰਖਿਆ ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਜੇ ਕਿਸੇ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਿੱਚ real ਸੰਖਿਆ ਹੋਵੇ, ਤਾਂ ਉਪਰੋਕਤ ਗਣਨਾਵਾਂ ਵਿੱਚ ਸਿਰਫ਼ ਉਸਦਾ real ਭਾਗ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

complex.from_number() ਵੀ ਵੇਖੋ, ਜੋ ਸਿਰਫ਼ ਇੱਕ ਸੰਖਿਆਤਮਕ ਆਰਗੂਮੈਂਟ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ।

ਜੇ ਸਾਰੇ ਆਰਗੂਮੈਂਟ ਛੱਡ ਦਿੱਤੇ ਜਾਣ, ਤਾਂ 0j ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

complex ਕਿਸਮ ਦਾ ਵੇਰਵਾ Numeric Types --- int, float, complex ਵਿੱਚ ਦਿੱਤਾ ਗਿਆ ਹੈ।

Changed in version 3.6: ਕੋਡ ਲਿਟਰਲਾਂ ਵਾਂਗ ਅੰਕਾਂ ਨੂੰ underscores ਨਾਲ ਸਮੂਹਬੱਧ ਕਰਨਾ ਮਨਜ਼ੂਰ ਹੈ।

Changed in version 3.8: ਜੇ __complex__() ਅਤੇ __float__() ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਹਨ, ਤਾਂ ਇਹ __index__() ਵੱਲ ਮੁੜਦਾ ਹੈ।

Deprecated since version 3.14: real ਜਾਂ imag ਆਰਗੂਮੈਂਟ ਵਜੋਂ complex ਸੰਖਿਆ ਦੇਣਾ ਹੁਣ deprecated ਹੈ; ਇਸਨੂੰ ਸਿਰਫ਼ ਇੱਕ positional argument ਵਜੋਂ ਹੀ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ।

delattr(object, name, /)

ਇਹ setattr() ਨਾਲ ਸੰਬੰਧਿਤ ਫੰਕਸ਼ਨ ਹੈ। ਆਰਗੂਮੈਂਟ ਇੱਕ ਆਬਜੈਕਟ ਅਤੇ ਇੱਕ ਸਟ੍ਰਿੰਗ ਹਨ। ਸਟਰਿੰਗ ਆਬਜੈਕਟ ਦੇ ਕਿਸੇ ਐਟ੍ਰਿਬਿਊਟ ਦਾ ਨਾਮ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਜੇ ਆਬਜੈਕਟ ਆਗਿਆ ਦੇਵੇ, ਤਾਂ ਇਹ ਫੰਕਸ਼ਨ ਉਸ ਐਟ੍ਰਿਬਿਊਟ ਨੂੰ ਮਿਟਾ ਦਿੰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, delattr(x, 'foobar') del x.foobar ਦੇ ਬਰਾਬਰ ਹੈ। name ਦਾ Python identifier ਹੋਣਾ ਲਾਜ਼ਮੀ ਨਹੀਂ ਹੈ (setattr() ਵੇਖੋ)।

class dict(**kwargs)

class dict(mapping, /, **kwargs)

class dict(iterable, /, **kwargs)

ਇੱਕ ਨਵੀਂ dictionary ਬਣਾਓ। dict object dictionary class ਹੈ। ਇਸ class ਬਾਰੇ ਦਸਤਾਵੇਜ਼ੀਕਰਨ ਲਈ Mapping types --- dict, frozendict ਵੀ ਵੇਖੋ।

ਹੋਰ ਕੰਟੇਨਰਾਂ ਲਈ built-in frozendict, list, set, ਅਤੇ tuple ਕਲਾਸਾਂ ਦੇ ਨਾਲ collections ਮੋਡੀਊਲ ਵੀ ਵੇਖੋ।

dir()

dir(object, /)

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

ਜੇ ਆਬਜੈਕਟ ਵਿੱਚ __dir__() ਨਾਮ ਦੀ ਮੈਥਡ ਹੋਵੇ, ਤਾਂ ਇਸਨੂੰ ਕਾਲ ਕੀਤਾ ਜਾਵੇਗਾ ਅਤੇ ਇਸਨੂੰ ਗੁਣਾਂ ਦੀ ਸੂਚੀ ਵਾਪਸ ਕਰਨੀ ਲਾਜ਼ਮੀ ਹੈ। ਇਸ ਨਾਲ ਉਹ ਆਬਜੈਕਟ ਜੋ ਕਸਟਮ __getattr__() ਜਾਂ __getattribute__() ਫੰਕਸ਼ਨ ਲਾਗੂ ਕਰਦੇ ਹਨ, dir() ਦੁਆਰਾ ਆਪਣੇ ਗੁਣਾਂ ਦੀ ਰਿਪੋਰਟ ਕਰਨ ਦੇ ਤਰੀਕੇ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰ ਸਕਦੇ ਹਨ।

ਜੇ ਆਬਜੈਕਟ __dir__() ਪ੍ਰਦਾਨ ਨਹੀਂ ਕਰਦਾ, ਤਾਂ ਇਹ ਫੰਕਸ਼ਨ ਆਬਜੈਕਟ ਦੇ __dict__ ਗੁਣ ਜੇ ਪਰਿਭਾਸ਼ਿਤ ਹੋਵੇ ਅਤੇ ਇਸਦੇ ਟਾਈਪ ਆਬਜੈਕਟ ਤੋਂ ਜਾਣਕਾਰੀ ਇਕੱਠੀ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ। ਨਤੀਜੇ ਵਜੋਂ ਮਿਲੀ ਸੂਚੀ ਲਾਜ਼ਮੀ ਤੌਰ 'ਤੇ ਪੂਰੀ ਨਹੀਂ ਹੁੰਦੀ ਅਤੇ ਜੇ ਆਬਜੈਕਟ ਵਿੱਚ ਕਸਟਮ __getattr__() ਹੋਵੇ ਤਾਂ ਇਹ ਗਲਤ ਵੀ ਹੋ ਸਕਦੀ ਹੈ।

ਮੂਲ dir() ਮਕੈਨਿਜ਼ਮ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਆਬਜੈਕਟਾਂ ਨਾਲ ਵੱਖਰੇ ਢੰਗ ਨਾਲ ਵਰਤਾਓ ਕਰਦਾ ਹੈ, ਕਿਉਂਕਿ ਇਹ ਪੂਰੀ ਜਾਣਕਾਰੀ ਦੀ ਬਜਾਏ ਸਭ ਤੋਂ ਵੱਧ ਸੰਬੰਧਿਤ ਜਾਣਕਾਰੀ ਦੇਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ:

• ਜੇ ਆਬਜੈਕਟ ਇੱਕ ਮੋਡੀਊਲ ਆਬਜੈਕਟ ਹੈ, ਤਾਂ ਸੂਚੀ ਵਿੱਚ ਮੋਡੀਊਲ ਦੇ ਗੁਣਾਂ ਦੇ ਨਾਮ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ।

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

• ਨਹੀਂ ਤਾਂ, ਸੂਚੀ ਵਿੱਚ ਆਬਜੈਕਟ ਦੇ ਗੁਣਾਂ ਦੇ ਨਾਮ, ਇਸਦੀ ਕਲਾਸ ਦੇ ਗੁਣਾਂ ਦੇ ਨਾਮ ਅਤੇ ਇਸ ਦੀਆਂ ਬੇਸ ਕਲਾਸਾਂ ਦੇ ਗੁਣਾਂ ਦੇ ਨਾਮ ਰਿਕਰਸਿਵ ਤਰੀਕੇ ਨਾਲ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ।

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

>>> import struct
>>> dir()   # show the names in the module namespace
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module
['Struct', '__all__', '__builtins__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
...
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

Note

ਕਿਉਂਕਿ dir() ਮੁੱਖ ਤੌਰ 'ਤੇ ਇੰਟਰਐਕਟਿਵ ਪ੍ਰਾਂਪਟ 'ਤੇ ਸੁਵਿਧਾ ਲਈ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਇਸ ਲਈ ਇਹ ਸਖ਼ਤੀ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਨਾਂਵਾਂ ਦੀ ਸੂਚੀ ਦੇਣ ਦੀ ਬਜਾਏ ਦਿਲਚਸਪ ਨਾਂਵਾਂ ਦਾ ਸੈੱਟ ਮੁਹੱਈਆ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ। ਇਸਦਾ ਵਿਸਤ੍ਰਿਤ ਵਰਤਾਓ ਵੱਖ-ਵੱਖ ਰਿਲੀਜ਼ਾਂ ਵਿੱਚ ਬਦਲ ਸਕਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, ਜਦੋਂ ਆਰਗੂਮੈਂਟ ਇੱਕ ਕਲਾਸ ਹੋਵੇ ਤਾਂ ਮੈਟਾਕਲਾਸ ਦੇ ਗੁਣ ਨਤੀਜੇ ਵਾਲੀ ਸੂਚੀ ਵਿੱਚ ਨਹੀਂ ਹੁੰਦੇ।

divmod(a, b, /)

ਦੋ (ਗੈਰ-ਕੰਪਲੈਕਸ) ਅੰਕਾਂ ਨੂੰ ਦਲੀਲਾਂ ਵਜੋਂ ਲਓ ਅਤੇ ਪੂਰਨ-ਭਾਗ-ਵੰਡ ਵਰਤ ਕੇ ਉਨ੍ਹਾਂ ਦੇ ਭਾਗਫਲ ਅਤੇ ਬਚਤ ਵਾਲੇ ਅੰਕਾਂ ਦੀ ਜੋੜੀ ਵਾਪਸ ਕਰੋ। ਮਿਲੇ-ਜੁਲੇ ਓਪਰੇਂਡ ਕਿਸਮਾਂ ਨਾਲ, ਬਾਈਨਰੀ ਗਣਿਤਿਕ ਓਪਰੇਟਰਾਂ ਦੇ ਨਿਯਮ ਲਾਗੂ ਹੁੰਦੇ ਹਨ। ਇੰਟਿਜਰਾਂ ਲਈ ਨਤੀਜਾ (a // b, a % b) ਦੇ ਬਰਾਬਰ ਹੁੰਦਾ ਹੈ। ਫਲੋਟਿੰਗ-ਪੁਆਇੰਟ ਨੰਬਰਾਂ ਲਈ ਨਤੀਜਾ (q, a % b) ਹੁੰਦਾ ਹੈ, ਜਿੱਥੇ q ਆਮ ਤੌਰ 'ਤੇ math.floor(a / b) ਹੁੰਦਾ ਹੈ ਪਰ ਇਹ ਉਸ ਤੋਂ 1 ਘੱਟ ਵੀ ਹੋ ਸਕਦਾ ਹੈ। ਕਿਸੇ ਵੀ ਹਾਲਤ ਵਿੱਚ q * b + a % b a ਦੇ ਬਹੁਤ ਨੇੜੇ ਹੁੰਦਾ ਹੈ, ਜੇ a % b ਗੈਰ-ਸ਼ੂਨ ਹੋਵੇ ਤਾਂ ਇਸਦਾ ਚਿੰਨ੍ਹ b ਦੇ ਚਿੰਨ੍ਹ ਦੇ ਬਰਾਬਰ ਹੁੰਦਾ ਹੈ, ਅਤੇ 0 <= abs(a % b) < abs(b) ।

enumerate(iterable, start=0)

ਇੱਕ enumerate ਆਬਜੈਕਟ ਵਾਪਸ ਕਰੋ। iterable ਇੱਕ ਸੀਕਵੈਂਸ, iterator, ਜਾਂ ਹੋਰ ਕੋਈ ਐਸਾ ਆਬਜੈਕਟ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ iteration ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੋਵੇ। enumerate() ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ iterator ਦੀ __next__() ਮੈਥਡ ਇੱਕ tuple ਵਾਪਸ ਕਰਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਗਿਣਤੀ (start ਤੋਂ, ਜਿਸਦਾ ਮੂਲ ਮੁੱਲ 0 ਹੈ) ਅਤੇ iterable 'ਤੇ iteration ਕਰਨ ਨਾਲ ਮਿਲੇ ਮੁੱਲ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ।

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

ਇਸਦੇ ਸਮਾਨ:

def enumerate(iterable, start=0):
    n = start
    for elem in iterable:
        yield n, elem
        n += 1

eval(source, /, globals=None, locals=None)

ਪੈਰਾਮੀਟਰ:

• source (str | code object) -- ਇੱਕ Python ਅਭਿਵਿਅੰਜਨਾ।

• globals (dict | frozendict | None) -- ਗਲੋਬਲ ਨੇਮਸਪੇਸ (ਮੂਲ: None)।

• locals (mapping | None) -- ਲੋਕਲ ਨੇਮਸਪੇਸ (ਮੂਲ: None)।

ਵਾਪਸੀ:

ਮੁਲਾਂਕਣ ਕੀਤੀ ਅਭਿਵਿਅੰਜਨਾ ਦਾ ਨਤੀਜਾ।

ਉਠਾਉਂਦਾ ਹੈ:

ਸਿੰਟੈਕਸ ਗਲਤੀਆਂ ਨੂੰ exceptions ਵਜੋਂ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ।

Warning

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

ਸੋਰਸ ਆਰਗੂਮੈਂਟ ਨੂੰ globals ਅਤੇ locals ਮੈਪਿੰਗਾਂ ਨੂੰ ਗਲੋਬਲ ਅਤੇ ਲੋਕਲ ਨੈਮਸਪੇਸ ਵਜੋਂ ਵਰਤ ਕੇ ਇੱਕ ਪਾਈਥਨ ਐਕਸਪ੍ਰੈਸ਼ਨ (ਤਕਨੀਕੀ ਤੌਰ 'ਤੇ, ਇੱਕ expression list) ਵਜੋਂ ਪਾਰਸ ਅਤੇ ਮੁਲਾਂਕਣ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਜੇ globals ਡਿਕਸ਼ਨਰੀ ਮੌਜੂਦ ਹੈ ਅਤੇ ਉਸ ਵਿੱਚ __builtins__ ਕੁੰਜੀ ਲਈ ਕੋਈ ਮੁੱਲ ਨਹੀਂ ਹੈ, ਤਾਂ source ਨੂੰ ਪਾਰਸ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਉਸ ਕੁੰਜੀ ਹੇਠ ਬਿਲਟ-ਇਨ ਮਾਡਿਊਲ builtins ਦੀ ਡਿਕਸ਼ਨਰੀ ਦਾ ਇੱਕ ਰੈਫਰੈਂਸ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। __builtins__ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਨਾ ਉਪਲਬਧ ਨਾਵਾਂ ਨੂੰ ਸੀਮਤ ਕਰਨ ਜਾਂ ਬਦਲਣ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਕੋਈ ਸੁਰੱਖਿਆ ਵਿਧੀ ਨਹੀਂ ਹੈ: ਚਲਾਇਆ ਗਿਆ ਕੋਡ ਫਿਰ ਵੀ ਸਾਰੇ ਬਿਲਟਇਨਜ਼ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦਾ ਹੈ। ਜੇ locals ਮੈਪਿੰਗ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਇਹ ਆਪਣੇ ਆਪ globals ਡਿਕਸ਼ਨਰੀ 'ਤੇ ਵਾਪਸ ਆ ਜਾਂਦਾ ਹੈ। ਜੇਕਰ ਦੋਵੇਂ ਮੈਪਿੰਗਾਂ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਸਰੋਤ ਉਸ ਵਾਤਾਵਰਣ ਵਿੱਚ globals ਅਤੇ locals ਨਾਲ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਜਿੱਥੇ eval() ਨੂੰ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਨੋਟ, eval() ਨੂੰ ਘੇਰਨ ਵਾਲੇ ਵਾਤਾਵਰਣ ਵਿੱਚ nested scopes (ਗੈਰ-ਲੋਕਲ) ਤੱਕ ਸਿਰਫ਼ ਉਦੋਂ ਹੀ ਪਹੁੰਚ ਮਿਲੇਗੀ ਜੇਕਰ ਉਹ ਪਹਿਲਾਂ ਹੀ ਉਸ ਸਕੋਪ ਵਿੱਚ ਹਵਾਲਾ ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ ਜੋ eval() ਨੂੰ ਕਾਲ ਕਰ ਰਿਹਾ ਹੈ (ਜਿਵੇਂ ਕਿ ਇੱਕ nonlocal ਬਿਆਨ ਰਾਹੀਂ)।

ਉਦਾਹਰਨ:

>>> x = 1
>>> eval('x+1')
2

>>> eval("1, 2")
(1, 2)

ਇਹ ਫੰਕਸ਼ਨ ਮਨਮਾਨੇ ਕੋਡ ਆਬਜੈਕਟਾਂ (ਜਿਵੇਂ ਕਿ compile() ਦੁਆਰਾ ਬਣਾਏ ਗਏ) ਨੂੰ ਚਲਾਉਣ ਲਈ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਸਟ੍ਰਿੰਗ ਦੀ ਬਜਾਏ ਇੱਕ ਕੋਡ ਆਬਜੈਕਟ ਦਿਓ। ਜੇ ਕੋਡ ਆਬਜੈਕਟ ਨੂੰ mode ਆਰਗੂਮੈਂਟ ਵਜੋਂ 'exec' ਨਾਲ ਕੰਪਾਇਲ ਕੀਤਾ ਗਿਆ ਹੋਵੇ, ਤਾਂ eval() ਦਾ ਵਾਪਸੀ ਮੁੱਲ None ਹੋਵੇਗਾ।

ਸੰਕੇਤ: statements ਦੇ ਡਾਇਨਾਮਿਕ ਚਲਾਓ ਨੂੰ exec() ਫੰਕਸ਼ਨ ਸਮਰਥਨ ਦਿੰਦਾ ਹੈ। globals() ਅਤੇ locals() ਫੰਕਸ਼ਨ ਕ੍ਰਮਵਾਰ ਮੌਜੂਦਾ ਗਲੋਬਲ ਅਤੇ ਲੋਕਲ ਡਿਕਸ਼ਨਰੀ ਵਾਪਸ ਕਰਦੇ ਹਨ, ਜੋ eval() ਜਾਂ exec() ਨਾਲ ਵਰਤੋਂ ਲਈ ਉਪਯੋਗੀ ਹੋ ਸਕਦੀਆਂ ਹਨ।

ਜੇ ਦਿੱਤਾ ਗਿਆ source ਇੱਕ ਸਟ੍ਰਿੰਗ ਹੈ, ਤਾਂ ਇਸਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਵਾਲੇ ਖਾਲੀ ਸਥਾਨ ਅਤੇ ਟੈਬ ਹਟਾ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ।

ਕੇਵਲ literal ਮੁੱਲਾਂ ਵਾਲੀਆਂ ਅਭਿਵਿਅੰਜਨਾਵਾਂ ਦੀਆਂ ਸਟ੍ਰਿੰਗਾਂ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਲਈ ast.literal_eval() ਵੇਖੋ।

ਕੋਡ ਆਬਜੈਕਟ ਨੂੰ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਵਰਤਦੇ ਹੋਏ auditing event exec ਉਠਾਇਆ ਜਾਂਦਾ ਹੈ। ਕੋਡ ਕੰਪਾਇਲੇਸ਼ਨ ਇਵੈਂਟ ਵੀ ਉਠਾਏ ਜਾ ਸਕਦੇ ਹਨ।

Changed in version 3.13: globals ਅਤੇ locals ਆਰਗੂਮੈਂਟ ਹੁਣ keyword arguments ਵਜੋਂ ਵੀ ਦਿੱਤੇ ਜਾ ਸਕਦੇ ਹਨ।

Changed in version 3.13: ਮੂਲ locals ਨੇਮਸਪੇਸ ਦੇ ਅਰਥਾਂ ਨੂੰ locals() builtin ਲਈ ਵਰਣਿਤ ਤਰੀਕੇ ਅਨੁਸਾਰ ਅਨੁਕੂਲਿਤ ਕੀਤਾ ਗਿਆ ਹੈ।

Changed in version 3.15: globals ਹੁਣ ਇੱਕ frozendict ਵੀ ਹੋ ਸਕਦਾ ਹੈ।

exec(source, /, globals=None, locals=None, *, closure=None)

Warning

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

ਇਹ ਫੰਕਸ਼ਨ ਪਾਈਥਨ ਕੋਡ ਦੀ ਡਾਇਨਾਮਿਕ ਚਲਾਉਣ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ। source ਜਾਂ ਤਾਂ ਇੱਕ ਸਟਰਿੰਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜਾਂ ਇੱਕ ਕੋਡ ਆਬਜੈਕਟ। ਜੇ ਇਹ ਸਟਰਿੰਗ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਪਾਈਥਨ ਬਿਆਨਾਂ ਦੇ ਇੱਕ ਸੂਟ ਵਜੋਂ ਪਾਰਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਫਿਰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ (ਜਦ ਤੱਕ ਕਿ ਕੋਈ ਸਿੰਟੈਕਸ ਗਲਤੀ ਨਾ ਹੋਵੇ)। [1] ਜੇ ਇਹ ਕੋਡ ਆਬਜੈਕਟ ਹੈ, ਤਾਂ ਇਹ ਸਿੱਧਾ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਸਾਰੇ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਚਲਾਇਆ ਗਿਆ ਕੋਡ ਫਾਈਲ ਇਨਪੁੱਟ ਵਜੋਂ ਵੈਧ ਹੋਣ ਦੀ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ (ਹਵਾਲਾ ਮੈਨੂਅਲ ਵਿੱਚ " File input " ਸੈਕਸ਼ਨ ਵੇਖੋ)। ਧਿਆਨ ਰੱਖੋ ਕਿ nonlocal, yield ਅਤੇ return ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਫੰਕਸ਼ਨ ਡੈਫੀਨੇਸ਼ਨਾਂ ਤੋਂ ਬਾਹਰ, ਇੱਥੋਂ ਤੱਕ ਕਿ exec() ਫੰਕਸ਼ਨ ਨੂੰ ਦਿੱਤੇ ਗਏ ਕੋਡ ਦੇ ਸੰਦਰਭ ਵਿੱਚ ਵੀ, ਵਰਤਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ। ਵਾਪਸੀ ਮੁੱਲ None ਹੈ।

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

Note

ਜਦੋਂ exec ਨੂੰ ਦੋ ਵੱਖ-ਵੱਖ ਵਸਤੂਆਂ globals ਅਤੇ locals ਵਜੋਂ ਮਿਲਦੀਆਂ ਹਨ, ਤਾਂ ਕੋਡ ਇਸ ਤਰ੍ਹਾਂ ਚਲਾਇਆ ਜਾਵੇਗਾ ਜਿਵੇਂ ਇਹ ਕਿਸੇ ਕਲਾਸ ਪਰਿਭਾਸ਼ਾ ਵਿੱਚ ਸ਼ਾਮਿਲ ਹੋਵੇ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਚਲਾਏ ਗਏ ਕੋਡ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਕਲਾਸਾਂ ਨੂੰ ਸਿਖਰਲੇ ਪੱਧਰ 'ਤੇ ਨਿਰਧਾਰਤ ਵੇਰੀਏਬਲਜ਼ ਤੱਕ ਪਹੁੰਚ ਨਹੀਂ ਮਿਲੇਗੀ (ਕਿਉਂਕਿ "ਸਿਖਰਲੇ ਪੱਧਰ" ਵੇਰੀਏਬਲਜ਼ ਨੂੰ ਕਲਾਸ ਪਰਿਭਾਸ਼ਾ ਵਿੱਚ ਕਲਾਸ ਵੇਰੀਏਬਲਜ਼ ਵਜੋਂ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ)।

ਜੇ globals ਡਿਕਸ਼ਨਰੀ ਵਿੱਚ __builtins__ ਕੁੰਜੀ ਲਈ ਕੋਈ ਮੁੱਲ ਨਹੀਂ ਹੈ, ਤਾਂ builtins ਮੋਡੀਊਲ ਦੀ ਡਿਕਸ਼ਨਰੀ ਦਾ ਹਵਾਲਾ ਉਸ ਕੁੰਜੀ ਹੇਠ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ। __builtins__ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਕੇ ਉਪਲਬਧ ਨਾਂਵਾਂ ਨੂੰ ਸੀਮਿਤ ਜਾਂ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਸੁਰੱਖਿਆ ਮਕੈਨਿਜ਼ਮ ਨਹੀਂ ਹੈ; ਚਲਾਇਆ ਗਿਆ ਕੋਡ ਫਿਰ ਵੀ ਸਾਰੇ builtins ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦਾ ਹੈ।

closure ਆਰਗੂਮੈਂਟ ਇੱਕ closure ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ — cellvars ਦਾ ਇੱਕ tuple। ਇਹ ਕੇਵਲ ਤਦ ਹੀ ਵੈਧ ਹੈ ਜਦੋਂ object ਇੱਕ ਐਸਾ code object ਹੋਵੇ ਜਿਸ ਵਿੱਚ free (closure) variables ਮੌਜੂਦ ਹੋਣ। tuple ਦੀ ਲੰਬਾਈ code object ਦੇ co_freevars ਦੀ ਲੰਬਾਈ ਦੇ ਬਰਾਬਰ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ।

ਕੋਡ ਆਬਜੈਕਟ ਨੂੰ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਵਰਤਦੇ ਹੋਏ auditing event exec ਉਠਾਇਆ ਜਾਂਦਾ ਹੈ। ਕੋਡ ਕੰਪਾਇਲੇਸ਼ਨ ਇਵੈਂਟ ਵੀ ਉਠਾਏ ਜਾ ਸਕਦੇ ਹਨ।

Note

ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ globals() ਅਤੇ locals() ਕ੍ਰਮਵਾਰ ਮੌਜੂਦਾ ਗਲੋਬਲ ਅਤੇ ਲੋਕਲ ਨੇਮਸਪੇਸ ਵਾਪਸ ਕਰਦੇ ਹਨ, ਜੋ exec() ਦੇ ਦੂਜੇ ਅਤੇ ਤੀਜੇ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਵਰਤਣ ਲਈ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦੇ ਹਨ।

Note

ਮੂਲ locals ਉਸੇ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ ਜਿਵੇਂ ਹੇਠਾਂ locals() ਲਈ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ। ਜੇ ਤੁਸੀਂ exec() ਦੇ ਵਾਪਸ ਆਉਣ ਤੋਂ ਬਾਅਦ locals ਉੱਤੇ ਕੋਡ ਦੇ ਪ੍ਰਭਾਵ ਦੇਖਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇੱਕ ਸਪਸ਼ਟ locals ਡਿਕਸ਼ਨਰੀ ਦਿਓ।

Changed in version 3.11: closure ਪੈਰਾਮੀਟਰ ਜੋੜਿਆ ਗਿਆ।

Changed in version 3.13: globals ਅਤੇ locals ਆਰਗੂਮੈਂਟ ਹੁਣ keyword arguments ਵਜੋਂ ਵੀ ਦਿੱਤੇ ਜਾ ਸਕਦੇ ਹਨ।

Changed in version 3.13: ਮੂਲ locals ਨੇਮਸਪੇਸ ਦੇ ਅਰਥਾਂ ਨੂੰ locals() builtin ਲਈ ਵਰਣਿਤ ਤਰੀਕੇ ਅਨੁਸਾਰ ਅਨੁਕੂਲਿਤ ਕੀਤਾ ਗਿਆ ਹੈ।

Changed in version 3.15: globals ਹੁਣ ਇੱਕ frozendict ਵੀ ਹੋ ਸਕਦਾ ਹੈ।

filter(function, iterable, /)

ਉਹਨਾਂ ਤੱਤਾਂ ਤੋਂ ਇੱਕ ਇਟਰੇਟਰ ਬਣਾਓ ਜੋ iterable ਦੇ ਉਹਨਾਂ ਤੱਤਾਂ ਲਈ function ਸਹੀ ਹੈ। iterable ਕਿਸੇ ਵੀ ਕ੍ਰਮ, ਇਟਰੇਸ਼ਨ ਸਹਿਯੋਗੀ ਕੰਟੇਨਰ, ਜਾਂ ਇਟਰੇਟਰ ਹੋ ਸਕਦਾ ਹੈ। ਜੇ function None ਹੈ, ਤਾਂ ਪਛਾਣ ਫੰਕਸ਼ਨ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ, ਅਰਥਾਤ iterable ਦੇ ਉਹ ਸਾਰੇ ਤੱਤ ਜੋ false ਹਨ, ਹਟਾ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ।

ਧਿਆਨ ਦਿਓ ਕਿ filter(function, iterable) generator expression (item for item in iterable if function(item)) ਦੇ ਬਰਾਬਰ ਹੈ ਜੇ function None ਨਾ ਹੋਵੇ, ਅਤੇ (item for item in iterable if item) ਦੇ ਬਰਾਬਰ ਹੈ ਜੇ function None ਹੋਵੇ।

ਉਸ ਪੂਰਕ ਫੰਕਸ਼ਨ ਲਈ itertools.filterfalse() ਵੇਖੋ ਜੋ iterable ਦੇ ਉਹ ਤੱਤ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਲਈ function false ਹੁੰਦਾ ਹੈ।

class float(number=0.0, /)

class float(string, /)

ਕਿਸੇ ਸੰਖਿਆ ਜਾਂ ਸਟ੍ਰਿੰਗ ਤੋਂ ਬਣਾਈ ਗਈ floating-point ਸੰਖਿਆ ਵਾਪਸ ਕਰੋ।

ਉਦਾਹਰਨਾਂ:

>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

ਜੇ ਆਰਗੂਮੈਂਟ ਇੱਕ ਸਟ੍ਰਿੰਗ ਹੈ, ਤਾਂ ਇਸ ਵਿੱਚ ਇੱਕ ਦਸ਼ਮਲਵ ਸੰਖਿਆ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਜਿਸ ਤੋਂ ਪਹਿਲਾਂ ਚਿੰਨ੍ਹ ਹੋ ਸਕਦਾ ਹੈ ਅਤੇ ਜਿਸ ਵਿੱਚ ਖਾਲੀ ਥਾਂਵਾਂ ਵੀ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਵਿਕਲਪਿਕ ਚਿੰਨ੍ਹ '+' ਜਾਂ '-' ਹੋ ਸਕਦਾ ਹੈ; '+' ਚਿੰਨ੍ਹ ਨਤੀਜੇ ਦੇ ਮੁੱਲ ਉੱਤੇ ਕੋਈ ਅਸਰ ਨਹੀਂ ਪਾਂਦਾ। ਆਰਗੂਮੈਂਟ ਇੱਕ NaN (ਸੰਖਿਆ ਨਹੀਂ) ਜਾਂ ਧਨਾਤਮਕ/ਰਿਣਾਤਮਕ ਅਨੰਤਤਾ ਦਰਸਾਉਣ ਵਾਲੀ ਸਟ੍ਰਿੰਗ ਵੀ ਹੋ ਸਕਦੀ ਹੈ। ਹੋਰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ, ਅੱਗੇ ਅਤੇ ਪਿੱਛੇ ਦੀਆਂ ਖਾਲੀ ਥਾਂਵਾਂ ਹਟਾਉਣ ਤੋਂ ਬਾਅਦ ਇਨਪੁੱਟ ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਵਿਆਕਰਣ ਦੇ floatvalue ਨਿਯਮ ਦਾ ਪਾਲਣ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ:

sign:          "+" | "-"
infinity:      "Infinity" | "inf"
nan:           "nan"
digit:         <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
digitpart:     digit (["_"] digit)*
number:        [digitpart] "." digitpart | digitpart ["."]
exponent:      ("e" | "E") [sign] digitpart
floatnumber:   number [exponent]
absfloatvalue: floatnumber | infinity | nan
floatvalue:    [sign] absfloatvalue

ਅੱਖਰਾਂ ਦਾ ਵੱਡਾ ਜਾਂ ਛੋਟਾ ਹੋਣਾ ਮਹੱਤਵਪੂਰਨ ਨਹੀਂ ਹੈ, ਇਸ ਲਈ ਉਦਾਹਰਨ ਵਜੋਂ "inf", "Inf", "INFINITY" ਅਤੇ "iNfINity" ਸਭ positive infinity ਲਈ ਸਵੀਕਾਰਯੋਗ ਹਨ।

ਨਹੀਂ ਤਾਂ, ਜੇ ਆਰਗੂਮੈਂਟ ਇੱਕ ਪੂਰਨ ਅੰਕ ਜਾਂ floating-point ਸੰਖਿਆ ਹੈ, ਤਾਂ ਉਸੇ ਮੁੱਲ ਵਾਲੀ floating-point ਸੰਖਿਆ (Python ਦੀ floating-point ਸ਼ੁੱਧਤਾ ਦੇ ਅੰਦਰ) ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਜੇ ਆਰਗੂਮੈਂਟ Python float ਦੀ ਸੀਮਾ ਤੋਂ ਬਾਹਰ ਹੋਵੇ, ਤਾਂ OverflowError ਉਠਾਈ ਜਾਵੇਗੀ।

ਆਮ Python ਆਬਜੈਕਟ x ਲਈ, float(x) x.__float__() ਨੂੰ ਸੌਂਪਿਆ ਜਾਂਦਾ ਹੈ। ਜੇ __float__() ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਹ __index__() ਉੱਤੇ ਵਾਪਸ ਜਾਂਦਾ ਹੈ।

float.from_number() ਵੀ ਵੇਖੋ, ਜੋ ਕੇਵਲ ਇੱਕ ਸੰਖਿਆਤਮਕ ਆਰਗੂਮੈਂਟ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ।

ਜੇ ਕੋਈ ਆਰਗੂਮੈਂਟ ਨਾ ਦਿੱਤਾ ਜਾਵੇ, ਤਾਂ 0.0 ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

float ਕਿਸਮ ਦਾ ਵੇਰਵਾ Numeric Types --- int, float, complex ਵਿੱਚ ਦਿੱਤਾ ਗਿਆ ਹੈ।

Changed in version 3.6: ਕੋਡ ਲਿਟਰਲਾਂ ਵਾਂਗ ਅੰਕਾਂ ਨੂੰ underscores ਨਾਲ ਸਮੂਹਬੱਧ ਕਰਨਾ ਮਨਜ਼ੂਰ ਹੈ।

Changed in version 3.7: ਹੁਣ ਇਹ ਪੈਰਾਮੀਟਰ ਕੇਵਲ positional ਰੂਪ ਵਿੱਚ ਹੀ ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ।

Changed in version 3.8: ਜੇ __float__() ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਹੈ, ਤਾਂ __index__() ਉੱਤੇ ਵਾਪਸ ਜਾਂਦਾ ਹੈ।

format(value, format_spec='', /)

value ਨੂੰ format_spec ਦੁਆਰਾ ਨਿਯੰਤਰਿਤ ਇੱਕ "ਫਾਰਮੈਟ ਕੀਤੀ" ਪੇਸ਼ਕਾਰੀ ਵਿੱਚ ਬਦਲੋ। format_spec ਦੀ ਵਿਆਖਿਆ value ਦੇ ਪ੍ਰਕਾਰ ਉੱਤੇ ਨਿਰਭਰ ਕਰੇਗੀ; ਹਾਲਾਂਕਿ, ਇੱਕ ਮਿਆਰੀ ਫਾਰਮੈਟਿੰਗ ਸੰਟੈਕਸ ਹੈ ਜੋ ਜ਼ਿਆਦਾਤਰ ਬਿਲਟ-ਇਨ ਕਿਸਮਾਂ ਵੱਲੋਂ ਵਰਤੀ ਜਾਂਦੀ ਹੈ: Format specification mini-language।

ਮੂਲ format_spec ਇੱਕ ਖਾਲੀ ਸਟ੍ਰਿੰਗ ਹੈ ਜੋ ਆਮ ਤੌਰ 'ਤੇ str(value) ਨੂੰ ਕਾਲ ਕਰਨ ਦੇ ਬਰਾਬਰ ਨਤੀਜਾ ਦਿੰਦੀ ਹੈ।

format(value, format_spec) ਕਾਲ ਨੂੰ type(value).__format__(value, format_spec) ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ, ਜੋ ਮੁੱਲ ਦੀ __format__() ਵਿਧੀ ਦੀ ਖੋਜ ਕਰਦੇ ਸਮੇਂ instance dictionary ਨੂੰ ਬਾਈਪਾਸ ਕਰਦਾ ਹੈ। ਜੇ ਵਿਧੀ ਖੋਜ object ਤੱਕ ਪਹੁੰਚ ਜਾਵੇ ਅਤੇ format_spec ਖਾਲੀ ਨਾ ਹੋਵੇ, ਜਾਂ format_spec ਜਾਂ ਵਾਪਸੀ ਮੁੱਲ ਵਿੱਚੋਂ ਕੋਈ ਵੀ ਸਟ੍ਰਿੰਗ ਨਾ ਹੋਵੇ, ਤਾਂ TypeError ਉਠਾਈ ਜਾਂਦੀ ਹੈ।

Changed in version 3.4: ਜੇ format_spec ਖਾਲੀ ਸਟ੍ਰਿੰਗ ਨਹੀਂ ਹੈ, ਤਾਂ object().__format__(format_spec) TypeError ਉਠਾਉਂਦਾ ਹੈ।

class frozendict(**kwargs)

class frozendict(mapping, /, **kwargs)

class frozendict(iterable, /, **kwargs)

ਇੱਕ ਨਵੀਂ frozen dictionary ਬਣਾਓ। frozendict object ਇੱਕ built-in class ਹੈ। ਇਸ class ਬਾਰੇ ਦਸਤਾਵੇਜ਼ੀਕਰਨ ਲਈ Mapping types --- dict, frozendict ਵੀ ਵੇਖੋ।

ਹੋਰ ਕੰਟੇਨਰਾਂ ਲਈ ਬਿਲਟ-ਇਨ dict, list, set, tuple ਕਲਾਸਾਂ ਅਤੇ collections ਮੋਡੀਊਲ ਵੇਖੋ।

Added in version 3.15.

class frozenset(iterable=(), /)

iterable ਤੋਂ ਲਏ ਗਏ ਤੱਤਾਂ ਨਾਲ, ਜਾਂ ਬਿਨਾਂ ਉਹਨਾਂ ਦੇ, ਇੱਕ ਨਵਾਂ frozenset object ਵਾਪਸ ਕਰੋ। frozenset ਇੱਕ built-in class ਹੈ। ਇਸ class ਬਾਰੇ ਦਸਤਾਵੇਜ਼ੀਕਰਨ ਲਈ Set Types --- set, frozenset ਵੀ ਵੇਖੋ।

ਹੋਰ ਕੰਟੇਨਰਾਂ ਲਈ ਬਿਲਟ-ਇਨ set, list, tuple, dict ਕਲਾਸਾਂ ਅਤੇ collections ਮੋਡੀਊਲ ਵੇਖੋ।

getattr(object, name, /)

getattr(object, name, default, /)

object ਦੇ ਦਿੱਤੇ ਗਏ ਨਾਮ ਵਾਲੇ ਐਟ੍ਰਿਬਿਊਟ ਦਾ ਮੁੱਲ ਵਾਪਸ ਕਰੋ। name ਇੱਕ ਸਟ੍ਰਿੰਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਜੇ ਸਟ੍ਰਿੰਗ ਆਬਜੈਕਟ ਦੇ ਕਿਸੇ ਐਟ੍ਰਿਬਿਊਟ ਦਾ ਨਾਮ ਹੈ, ਤਾਂ ਨਤੀਜਾ ਉਸ ਐਟ੍ਰਿਬਿਊਟ ਦਾ ਮੁੱਲ ਹੋਵੇਗਾ। ਉਦਾਹਰਨ ਲਈ, getattr(x, 'foobar') ਦਾ ਅਰਥ x.foobar ਦੇ ਬਰਾਬਰ ਹੈ। ਜੇ ਦਿੱਤਾ ਐਟ੍ਰਿਬਿਊਟ ਮੌਜੂਦ ਨਹੀਂ ਹੈ, ਤਾਂ default ਦਿੱਤਾ ਹੋਣ 'ਤੇ ਉਹ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਨਹੀਂ ਤਾਂ AttributeError ਉਠਾਈ ਜਾਂਦੀ ਹੈ। name ਦਾ Python identifier ਹੋਣਾ ਲਾਜ਼ਮੀ ਨਹੀਂ ਹੈ (ਵੇਖੋ setattr())।

Note

ਕਿਉਂਕਿ private name mangling ਕੰਪਾਈਲ ਸਮੇਂ ਹੁੰਦੀ ਹੈ, ਇਸ ਲਈ ਕਿਸੇ private ਐਟ੍ਰਿਬਿਊਟ (ਦੋ ਅਗਲੇ underscore ਵਾਲੇ ਐਟ੍ਰਿਬਿਊਟ) ਨੂੰ getattr() ਨਾਲ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਉਸਦਾ ਨਾਮ ਹੱਥੋਂ ਮੰਗਲ ਕਰਨਾ ਪੈਂਦਾ ਹੈ।

globals()

ਮੌਜੂਦਾ ਮੋਡੀਊਲ namespace ਨੂੰ ਲਾਗੂ ਕਰਨ ਵਾਲੀ dictionary ਵਾਪਸ ਕਰੋ। ਫੰਕਸ਼ਨਾਂ ਦੇ ਅੰਦਰਲੇ ਕੋਡ ਲਈ, ਇਹ ਫੰਕਸ਼ਨ ਦੀ ਪਰਿਭਾਸ਼ਾ ਸਮੇਂ ਸੈੱਟ ਹੁੰਦੀ ਹੈ ਅਤੇ ਫੰਕਸ਼ਨ ਨੂੰ ਕਿਤੇ ਵੀ ਕਾਲ ਕੀਤਾ ਜਾਵੇ, ਇਹ ਇੱਕੋ ਹੀ ਰਹਿੰਦੀ ਹੈ।

hasattr(object, name, /)

ਆਰਗੂਮੈਂਟ ਇੱਕ ਆਬਜੈਕਟ ਅਤੇ ਇੱਕ ਸਟ੍ਰਿੰਗ ਹੁੰਦੇ ਹਨ। ਜੇ ਸਟ੍ਰਿੰਗ ਆਬਜੈਕਟ ਦੇ ਕਿਸੇ ਐਟ੍ਰਿਬਿਊਟ ਦਾ ਨਾਮ ਹੈ, ਤਾਂ ਨਤੀਜਾ True ਹੁੰਦਾ ਹੈ, ਨਹੀਂ ਤਾਂ False। (ਇਹ getattr(object, name) ਨੂੰ ਕਾਲ ਕਰਕੇ ਅਤੇ ਇਹ ਦੇਖ ਕੇ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਕਿ ਕੀ ਉਹ AttributeError ਉਠਾਉਂਦਾ ਹੈ ਜਾਂ ਨਹੀਂ।)

hash(object, /)

ਆਬਜੈਕਟ ਦਾ hash ਮੁੱਲ ਵਾਪਸ ਕਰੋ (ਜੇ ਇਸਦਾ ਕੋਈ hash ਮੁੱਲ ਹੈ)। Hash ਮੁੱਲ ਪੂਰਨ ਅੰਕ ਹੁੰਦੇ ਹਨ। ਇਹ dictionary lookup ਦੌਰਾਨ keys ਦੀ ਤੇਜ਼ ਤੁਲਨਾ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ। ਜੋ ਸੰਖਿਆਤਮਕ ਮੁੱਲ ਇੱਕੋ ਜਿਹੇ ਮੰਨੇ ਜਾਂਦੇ ਹਨ, ਉਨ੍ਹਾਂ ਦਾ hash ਮੁੱਲ ਵੀ ਇੱਕੋ ਹੁੰਦਾ ਹੈ (ਭਾਵੇਂ ਉਹ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਹੋਣ, ਜਿਵੇਂ 1 ਅਤੇ 1.0)।

Note

ਜਿਨ੍ਹਾਂ ਆਬਜੈਕਟਾਂ ਵਿੱਚ custom __hash__() ਵਿਧੀਆਂ ਹਨ, ਉਨ੍ਹਾਂ ਲਈ ਧਿਆਨ ਦਿਓ ਕਿ hash() ਵਾਪਸੀ ਮੁੱਲ ਨੂੰ host ਮਸ਼ੀਨ ਦੀ bit width ਦੇ ਅਧਾਰ 'ਤੇ ਕੱਟ ਦਿੰਦਾ ਹੈ।

help()

help(request)

ਬਿਲਟ-ਇਨ help ਸਿਸਟਮ ਨੂੰ ਚਲਾਓ। (ਇਹ ਫੰਕਸ਼ਨ ਇੰਟਰਐਕਟਿਵ ਵਰਤੋਂ ਲਈ ਬਣਾਇਆ ਗਿਆ ਹੈ।) ਜੇ ਕੋਈ ਆਰਗੂਮੈਂਟ ਨਹੀਂ ਦਿੱਤਾ ਜਾਂਦਾ, ਤਾਂ interpreter console ਉੱਤੇ interactive help system ਸ਼ੁਰੂ ਹੋ ਜਾਂਦਾ ਹੈ। ਜੇ ਆਰਗੂਮੈਂਟ ਇੱਕ ਸਟ੍ਰਿੰਗ ਹੈ, ਤਾਂ ਉਸਨੂੰ module, function, class, method, keyword ਜਾਂ documentation topic ਦੇ ਨਾਮ ਵਜੋਂ ਲੱਭਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ console ਉੱਤੇ ਇੱਕ help page ਦਿਖਾਇਆ ਜਾਂਦਾ ਹੈ। ਜੇ ਆਰਗੂਮੈਂਟ ਕਿਸੇ ਹੋਰ ਕਿਸਮ ਦਾ ਆਬਜੈਕਟ ਹੈ, ਤਾਂ ਉਸ ਆਬਜੈਕਟ ਲਈ help page ਤਿਆਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਧਿਆਨ ਦਿਓ ਕਿ ਜਦੋਂ help() ਵਰਤਦੇ ਸਮੇਂ ਕਿਸੇ ਫੰਕਸ਼ਨ ਦੀ parameter ਸੂਚੀ ਵਿੱਚ slash (/) ਦਿਖਾਈ ਦੇਵੇ, ਤਾਂ ਇਸਦਾ ਅਰਥ ਹੈ ਕਿ slash ਤੋਂ ਪਹਿਲਾਂ ਵਾਲੇ parameters ਸਿਰਫ positional ਹਨ। ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ the FAQ entry on positional-only parameters ਵੇਖੋ।

ਇਹ ਫੰਕਸ਼ਨ site ਮੋਡੀਊਲ ਦੁਆਰਾ built-in namespace ਵਿੱਚ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ।

Changed in version 3.4: pydoc ਅਤੇ inspect ਵਿੱਚ ਕੀਤੀਆਂ ਤਬਦੀਲੀਆਂ ਕਾਰਨ callables ਲਈ ਦਿਖਾਏ ਜਾਣ ਵਾਲੇ signatures ਹੁਣ ਹੋਰ ਵਿਸਤ੍ਰਿਤ ਅਤੇ ਇੱਕਸਾਰ ਹਨ।

hex(integer, /)

ਇੱਕ ਪੂਰਨ ਅੰਕ ਨੂੰ ''0x'' ਪ੍ਰੀਫਿਕਸ ਵਾਲੀ lowercase hexadecimal ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਬਦਲੋ। ਜੇ integer ਇੱਕ Python int ਆਬਜੈਕਟ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਸ ਵਿੱਚ ਅਜਿਹੀ __index__() ਵਿਧੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ ਜੋ ਇੱਕ ਪੂਰਨ ਅੰਕ ਵਾਪਸ ਕਰੇ। ਕੁਝ ਉਦਾਹਰਨਾਂ:

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

ਜੇ ਤੁਸੀਂ ਕਿਸੇ ਪੂਰਨ ਅੰਕ ਨੂੰ ਪ੍ਰੀਫਿਕਸ ਸਮੇਤ ਜਾਂ ਬਿਨਾਂ ਪ੍ਰੀਫਿਕਸ ਦੇ uppercase ਜਾਂ lowercase hexadecimal ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਕਿਸੇ ਵੀ ਤਰੀਕੇ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ:

>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')

ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ format() ਵੀ ਵੇਖੋ।

hexadecimal ਸਟ੍ਰਿੰਗ ਨੂੰ base 16 ਦੀ ਵਰਤੋਂ ਨਾਲ ਪੂਰਨ ਅੰਕ ਵਿੱਚ ਬਦਲਣ ਲਈ int() ਵੀ ਵੇਖੋ।

Note

ਕਿਸੇ float ਦੀ hexadecimal ਸਟ੍ਰਿੰਗ ਨੁਮਾਇੰਦਗੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ float.hex() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।

id(object, /)

ਕਿਸੇ ਆਬਜੈਕਟ ਦੀ "identity" ਵਾਪਸ ਕਰੋ। ਇਹ ਇੱਕ ਪੂਰਨ ਅੰਕ ਹੁੰਦਾ ਹੈ ਜੋ ਆਬਜੈਕਟ ਦੀ ਪੂਰੀ ਉਮਰ ਦੌਰਾਨ ਵਿਲੱਖਣ ਅਤੇ ਅਪਰਿਵਰਤਿਤ ਹੋਣ ਦੀ ਗਾਰੰਟੀ ਰੱਖਦਾ ਹੈ। ਦੋ ਆਬਜੈਕਟ ਜਿਨ੍ਹਾਂ ਦੀਆਂ lifetimes ਆਪਸ ਵਿੱਚ ਨਹੀਂ ਮਿਲਦੀਆਂ, ਉਹਨਾਂ ਦਾ id() ਮੁੱਲ ਇੱਕੋ ਜਿਹਾ ਹੋ ਸਕਦਾ ਹੈ।

ਇਹ memory ਵਿੱਚ ਆਬਜੈਕਟ ਦਾ ਪਤਾ ਹੁੰਦਾ ਹੈ।

id ਆਰਗੂਮੈਂਟ ਨਾਲ auditing event builtins.id ਉਠਾਉਂਦਾ ਹੈ।

input()

input(prompt, /)

ਜੇ prompt ਆਰਗੂਮੈਂਟ ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ, ਤਾਂ ਇਸਨੂੰ standard output ਉੱਤੇ ਅੰਤ ਵਿੱਚ newline ਤੋਂ ਬਿਨਾਂ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ। ਫਿਰ ਫੰਕਸ਼ਨ input ਵਿੱਚੋਂ ਇੱਕ ਲਾਈਨ ਪੜ੍ਹਦਾ ਹੈ, ਇਸਨੂੰ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਬਦਲਦਾ ਹੈ (ਅੰਤਲੀ newline ਹਟਾ ਕੇ) ਅਤੇ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਜਦੋਂ EOF ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ EOFError ਉਠਾਈ ਜਾਂਦੀ ਹੈ। ਉਦਾਹਰਨ:

>>> s = input('--> ')
--> Monty Python's Flying Circus
>>> s
"Monty Python's Flying Circus"

ਜੇ readline ਮੋਡੀਊਲ ਲੋਡ ਕੀਤਾ ਗਿਆ ਹੋਵੇ, ਤਾਂ input() ਲਾਈਨ ਸੰਪਾਦਨ ਅਤੇ history ਦੀਆਂ ਉੱਨਤ ਸੁਵਿਧਾਵਾਂ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਇਸਦੀ ਵਰਤੋਂ ਕਰੇਗਾ।

input ਪੜ੍ਹਨ ਤੋਂ ਪਹਿਲਾਂ prompt ਆਰਗੂਮੈਂਟ ਨਾਲ auditing event builtins.input ਉਠਾਉਂਦਾ ਹੈ

input ਸਫਲਤਾਪੂਰਵਕ ਪੜ੍ਹਨ ਤੋਂ ਬਾਅਦ ਨਤੀਜੇ ਸਮੇਤ auditing event builtins.input/result ਉਠਾਉਂਦਾ ਹੈ।

class int(number=0, /)

class int(string, /, base=10)

ਕਿਸੇ ਸੰਖਿਆ ਜਾਂ ਸਟ੍ਰਿੰਗ ਤੋਂ ਬਣਾਇਆ ਗਿਆ ਇੱਕ ਪੂਰਨ ਅੰਕ ਆਬਜੈਕਟ ਵਾਪਸ ਕਰੋ, ਜਾਂ ਜੇ ਕੋਈ ਆਰਗੂਮੈਂਟ ਨਾ ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ ਤਾਂ 0 ਵਾਪਸ ਕਰੋ।

ਉਦਾਹਰਨਾਂ:

>>> int(123.45)
123
>>> int('123')
123
>>> int('   -12_345\n')
-12345
>>> int('FACE', 16)
64206
>>> int('0xface', 0)
64206
>>> int('01110011', base=2)
115

ਜੇ ਆਰਗੂਮੈਂਟ __int__() ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਤਾਂ int(x) x.__int__() ਵਾਪਸ ਕਰਦਾ ਹੈ। ਜੇ ਆਰਗੂਮੈਂਟ __index__() ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਤਾਂ ਇਹ x.__index__() ਵਾਪਸ ਕਰਦਾ ਹੈ। Floating-point ਸੰਖਿਆਵਾਂ ਲਈ, ਇਹ ਦਸ਼ਮਲਵ ਭਾਗ ਕੱਟ ਕੇ ਸਿਫ਼ਰ ਵੱਲ ਲੈ ਜਾਂਦਾ ਹੈ।

ਜੇ ਆਰਗੂਮੈਂਟ ਕੋਈ ਸੰਖਿਆ ਨਹੀਂ ਹੈ ਜਾਂ base ਦਿੱਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਇਹ ਇੱਕ ਸਟ੍ਰਿੰਗ, bytes, ਜਾਂ bytearray ਇੰਸਟੈਂਸ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ radix base ਵਿੱਚ ਇੱਕ ਪੂਰਨ ਅੰਕ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੋਵੇ। ਚੋਣਵਾਂ ਤੌਰ 'ਤੇ, ਸਟ੍ਰਿੰਗ ਦੇ ਅੱਗੇ + ਜਾਂ - ਹੋ ਸਕਦਾ ਹੈ (ਵਿਚਕਾਰ ਕੋਈ ਖਾਲੀ ਥਾਂ ਨਹੀਂ), ਸ਼ੁਰੂਆਤੀ ਸਿਫ਼ਰ ਹੋ ਸਕਦੇ ਹਨ, whitespace ਨਾਲ ਘਿਰੀ ਹੋ ਸਕਦੀ ਹੈ, ਅਤੇ ਅੰਕਾਂ ਦੇ ਵਿਚਕਾਰ ਇਕੱਲੇ underscore ਹੋ ਸਕਦੇ ਹਨ।

base-n ਪੂਰਨ ਅੰਕ ਸਤਰ ਵਿੱਚ ਅੰਕ ਹੁੰਦੇ ਹਨ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਹਰ ਇੱਕ 0 ਤੋਂ n-1 ਤੱਕ ਦੀ ਇੱਕ ਕੀਮਤ ਦਰਸਾਉਂਦਾ ਹੈ। 0--9 ਵਾਲੀਆਂ ਕੀਮਤਾਂ ਕਿਸੇ ਵੀ Unicode decimal digit ਨਾਲ ਦਰਸਾਈਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ। 10--35 ਵਾਲੀਆਂ ਕੀਮਤਾਂ ਨੂੰ a ਤੋਂ z (ਜਾਂ A ਤੋਂ Z) ਨਾਲ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਡਿਫਾਲਟ base 10 ਹੈ। ਮਨਜ਼ੂਰਸ਼ੁਦਾ bases 0 ਅਤੇ 2--36 ਹਨ। Base-2, -8 ਅਤੇ -16 ਸਤਰਾਂ ਨੂੰ ਕੋਡ ਵਿੱਚ integer literals ਦੀ ਤਰ੍ਹਾਂ ਚੋਣਵਾਂ ਤੌਰ 'ਤੇ 0b/0B, 0o/0O ਜਾਂ 0x/0X ਨਾਲ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। Base 0 ਲਈ, ਸਤਰ ਦੀ ਵਿਆਖਿਆ ਕੋਡ ਵਿੱਚ integer literal ਵਾਂਗ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿੱਥੇ ਅਸਲ base prefix ਦੇ ਅਧਾਰ 'ਤੇ 2, 8, 10 ਜਾਂ 16 ਹੁੰਦਾ ਹੈ। Base 0 ਸ਼ੁਰੂਆਤੀ zeros ਨੂੰ ਵੀ ਮਨਜ਼ੂਰ ਨਹੀਂ ਕਰਦਾ: int('010', 0) ਵੈਧ ਨਹੀਂ ਹੈ, ਜਦਕਿ int('010') ਅਤੇ int('010', 8) ਵੈਧ ਹਨ।

ਪੂਰਨ ਅੰਕ ਕਿਸਮ ਦਾ ਵੇਰਵਾ Numeric Types --- int, float, complex ਵਿੱਚ ਦਿੱਤਾ ਗਿਆ ਹੈ।

Changed in version 3.4: ਜੇ base int ਦਾ ਇੰਸਟੈਂਸ ਨਹੀਂ ਹੈ ਅਤੇ base ਆਬਜੈਕਟ ਕੋਲ base.__index__ ਮੈਥਡ ਹੈ, ਤਾਂ ਬੇਸ ਲਈ ਇਕ ਇੰਟਿਜਰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਉਹ ਮੈਥਡ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਪਿਛਲੇ ਵਰਜਨਾਂ ਨੇ base.__int__ ਦੀ ਵਰਤੋਂ base.__index__ ਦੀ ਥਾਂ ਕੀਤੀ ਸੀ।

Changed in version 3.6: ਕੋਡ ਲਿਟਰਲਾਂ ਵਾਂਗ ਅੰਕਾਂ ਨੂੰ underscores ਨਾਲ ਸਮੂਹਬੱਧ ਕਰਨਾ ਮਨਜ਼ੂਰ ਹੈ।

Changed in version 3.7: ਪਹਿਲਾ parameter ਹੁਣ ਸਿਰਫ positional ਹੈ।

Changed in version 3.8: ਜੇ __int__() ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਹੈ, ਤਾਂ __index__() ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

Changed in version 3.11: ਸੇਵਾ-ਇਨਕਾਰ ਹਮਲਿਆਂ ਤੋਂ ਬਚਾਅ ਲਈ int ਸਟ੍ਰਿੰਗ ਇਨਪੁੱਟਾਂ ਅਤੇ ਸਟ੍ਰਿੰਗ ਨੁਮਾਇੰਦਗੀਆਂ ਦੀ ਲੰਬਾਈ ਸੀਮਿਤ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਜਦੋਂ ਕਿਸੇ ਸਟ੍ਰਿੰਗ ਨੂੰ int ਵਿੱਚ ਬਦਲਦੇ ਸਮੇਂ ਜਾਂ ਕਿਸੇ int ਨੂੰ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਬਦਲਦੇ ਸਮੇਂ ਇਹ ਸੀਮਾ ਪਾਰ ਹੋ ਜਾਵੇ, ਤਾਂ ValueError ਉਠਾਈ ਜਾਂਦੀ ਹੈ। ਵੇਰਵਿਆਂ ਲਈ integer string conversion length limitation ਵੇਖੋ।

Changed in version 3.14: int() ਹੁਣ __trunc__() ਵਿਧੀ ਨੂੰ delegate ਨਹੀਂ ਕਰਦਾ।

isinstance(object, classinfo, /)

ਜੇ object ਆਰਗੂਮੈਂਟ classinfo ਆਰਗੂਮੈਂਟ ਦੀ ਕਿਸੇ ਇੰਸਟੈਂਸ ਜਾਂ ਇਸ ਦੀ (ਸਿੱਧੀ, ਅਸਿੱਧੀ ਜਾਂ virtual) ਉਪ-ਕਲਾਸ ਦੀ ਇੰਸਟੈਂਸ ਹੈ, ਤਾਂ True ਵਾਪਸ ਕਰੋ। ਜੇ object ਦਿੱਤੇ ਗਏ ਕਿਸਮ ਦਾ ਆਬਜੈਕਟ ਨਹੀਂ ਹੈ, ਤਾਂ ਫੰਕਸ਼ਨ ਹਮੇਸ਼ਾਂ False ਵਾਪਸ ਕਰਦਾ ਹੈ। ਜੇ classinfo ਕਿਸਮ ਦੇ ਆਬਜੈਕਟਾਂ ਦਾ ਇੱਕ ਟੂਪਲ (ਜਾਂ ਪੁਨਰ-ਸੰਦਰਭ ਵਿੱਚ ਹੋਰ ਐਸੇ ਟੂਪਲ) ਜਾਂ ਕਈ ਕਿਸਮਾਂ ਦਾ ਇੱਕ Union Type ਹੈ, ਤਾਂ ਜੇ object ਕਿਸੇ ਵੀ ਕਿਸਮ ਦਾ ਇੰਸਟੈਂਸ ਹੈ, ਤਾਂ True ਵਾਪਸ ਕਰੋ। ਜੇ classinfo ਕਿਸੇ ਟਾਈਪ ਜਾਂ ਟਾਈਪਾਂ ਦੇ ਟਿਊਪਲ ਜਾਂ ਅਜਿਹੇ ਹੋਰ ਟਿਊਪਲ ਨਹੀਂ ਹੈ, ਤਾਂ ਇੱਕ TypeError ਐਕਸੈਪਸ਼ਨ ਉਠਾਈ ਜਾਂਦੀ ਹੈ। ਜੇ ਪਹਿਲਾਂ ਕੀਤੀ ਜਾਂਚ ਸਫਲ ਰਹਿੰਦੀ ਹੈ, ਤਾਂ ਗਲਤ ਟਾਈਪ ਲਈ TypeError ਨਹੀਂ ਉਠਾਈ ਜਾ ਸਕਦੀ।

Changed in version 3.10: classinfo ਇੱਕ Union Type ਹੋ ਸਕਦਾ ਹੈ।

issubclass(cls, classinfo, /)

ਜੇ cls, classinfo ਦੀ (ਸਿੱਧੀ, ਅਸਿੱਧੀ ਜਾਂ virtual) subclass ਹੈ, ਤਾਂ True ਵਾਪਸ ਕਰੋ। ਇੱਕ class ਨੂੰ ਆਪਣੀ ਆਪ ਦੀ subclass ਵੀ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। classinfo class objects ਦਾ tuple (ਜਾਂ recursive ਤੌਰ 'ਤੇ ਅਜਿਹੇ ਹੋਰ tuples) ਜਾਂ Union Type ਹੋ ਸਕਦਾ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ ਜੇ cls, classinfo ਵਿੱਚ ਦਿੱਤੀ ਕਿਸੇ ਵੀ entry ਦੀ subclass ਹੈ, ਤਾਂ True ਵਾਪਸ ਕਰੋ। ਹੋਰ ਕਿਸੇ ਵੀ ਸਥਿਤੀ ਵਿੱਚ TypeError exception ਉਠਾਈ ਜਾਂਦੀ ਹੈ।

Changed in version 3.10: classinfo ਇੱਕ Union Type ਹੋ ਸਕਦਾ ਹੈ।

iter(iterable, /)

iter(callable, sentinel, /)

ਇੱਕ iterator object ਵਾਪਸ ਕਰੋ। ਪਹਿਲੇ argument ਦੀ ਵਿਆਖਿਆ ਦੂਜੇ argument ਦੀ ਮੌਜੂਦਗੀ ਦੇ ਅਨੁਸਾਰ ਵੱਖ-ਵੱਖ ਤਰੀਕੇ ਨਾਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਦੂਜੇ argument ਤੋਂ ਬਿਨਾਂ, ਇੱਕੋ argument ਕੋਈ collection object ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ iterable protocol (__iter__() method) ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੋਵੇ, ਜਾਂ sequence protocol (__getitem__() method ਜਿਸਦੇ integer arguments 0 ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ) ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੋਵੇ। ਜੇ ਇਹ ਦੋਨਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਦਾ ਵੀ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦਾ, ਤਾਂ TypeError ਉਠਾਈ ਜਾਂਦੀ ਹੈ। ਜੇ ਦੂਜਾ argument sentinel ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ, ਤਾਂ ਪਹਿਲਾ argument ਇੱਕ callable object ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ ਬਣਿਆ iterator ਆਪਣੀ __next__() method ਦੀ ਹਰ ਕਾਲ ਲਈ callable ਨੂੰ ਬਿਨਾਂ ਕਿਸੇ argument ਦੇ ਕਾਲ ਕਰੇਗਾ; ਜੇ ਵਾਪਸ ਆਈ ਕੀਮਤ sentinel ਦੇ ਬਰਾਬਰ ਹੋਵੇ ਤਾਂ StopIteration ਉਠਾਈ ਜਾਵੇਗੀ, ਨਹੀਂ ਤਾਂ ਉਹ ਕੀਮਤ ਵਾਪਸ ਕੀਤੀ ਜਾਵੇਗੀ।

Iteration-related types ਵੀ ਵੇਖੋ।

iter() ਦੇ ਦੂਜੇ ਰੂਪ ਦੀ ਇੱਕ ਲਾਭਦਾਇਕ ਵਰਤੋਂ block-reader ਬਣਾਉਣਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਕਿਸੇ binary ਡੇਟਾਬੇਸ ਫ਼ਾਈਲ ਵਿੱਚੋਂ ਨਿਰਧਾਰਤ ਚੌੜਾਈ ਵਾਲੇ block ਉਦੋਂ ਤੱਕ ਪੜ੍ਹਨਾ ਜਦੋਂ ਤੱਕ ਫ਼ਾਈਲ ਦਾ ਅੰਤ ਨਾ ਆ ਜਾਵੇ:

from functools import partial
with open('mydata.db', 'rb') as f:
    for block in iter(partial(f.read, 64), b''):
        process_block(block)

len(object, /)

ਕਿਸੇ object ਦੀ ਲੰਬਾਈ (items ਦੀ ਗਿਣਤੀ) ਵਾਪਸ ਕਰੋ। Argument ਕੋਈ sequence (ਜਿਵੇਂ string, bytes, tuple, list ਜਾਂ range) ਜਾਂ ਕੋਈ collection (ਜਿਵੇਂ dictionary, set ਜਾਂ frozen set) ਹੋ ਸਕਦਾ ਹੈ।

ਜੇ ਲੰਬਾਈ sys.maxsize ਤੋਂ ਵੱਡੀ ਹੋਵੇ, ਜਿਵੇਂ range(2 ** 100), ਤਾਂ len OverflowError ਉਠਾਉਂਦਾ ਹੈ।

class list(iterable=(), /)

ਫੰਕਸ਼ਨ ਹੋਣ ਦੀ ਬਜਾਇ, list ਅਸਲ ਵਿੱਚ ਇੱਕ mutable sequence ਕਿਸਮ ਹੈ, ਜਿਵੇਂ Lists ਅਤੇ Sequence Types --- list, tuple, range ਵਿੱਚ ਦਰਸਾਇਆ ਗਿਆ ਹੈ।

locals()

ਮੌਜੂਦਾ local symbol table ਨੂੰ ਦਰਸਾਉਣ ਵਾਲਾ mapping ਆਬਜੈਕਟ ਵਾਪਸ ਕਰੋ, ਜਿਸ ਵਿੱਚ variable ਨਾਮ keys ਵਜੋਂ ਅਤੇ ਉਹਨਾਂ ਦੇ ਮੌਜੂਦਾ bound references values ਵਜੋਂ ਹੁੰਦੇ ਹਨ।

ਮੋਡੀਊਲ ਸਕੋਪ ਵਿੱਚ, ਅਤੇ ਜਦੋਂ exec() ਜਾਂ eval() ਨੂੰ ਇੱਕੋ namespace ਨਾਲ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਇਹ ਫੰਕਸ਼ਨ globals() ਵਾਲਾ ਹੀ namespace ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਕਲਾਸ ਸਕੋਪ ਵਿੱਚ, ਇਹ ਉਹ namespace ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ metaclass constructor ਨੂੰ ਦਿੱਤਾ ਜਾਵੇਗਾ।

ਜਦੋਂ exec() ਜਾਂ eval() ਨੂੰ ਵੱਖਰੇ local ਅਤੇ global ਆਰਗੂਮੈਂਟਾਂ ਨਾਲ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਫੰਕਸ਼ਨ ਕਾਲ ਨੂੰ ਦਿੱਤਾ ਗਿਆ local namespace ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਉਪਰੋਕਤ ਸਾਰੀਆਂ ਸਥਿਤੀਆਂ ਵਿੱਚ, execution ਦੇ ਕਿਸੇ ਦਿੱਤੇ frame ਵਿੱਚ locals() ਦੀ ਹਰ ਕਾਲ ਉਹੀ mapping ਆਬਜੈਕਟ ਵਾਪਸ ਕਰੇਗੀ। locals() ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ mapping ਆਬਜੈਕਟ ਰਾਹੀਂ ਕੀਤੀਆਂ ਤਬਦੀਲੀਆਂ assigned, reassigned ਜਾਂ deleted local variables ਵਜੋਂ ਦਿਖਾਈ ਦੇਣਗੀਆਂ, ਅਤੇ local variables ਨੂੰ assign, reassign ਜਾਂ delete ਕਰਨ ਨਾਲ ਵਾਪਸ ਕੀਤੇ mapping ਆਬਜੈਕਟ ਦੀ ਸਮੱਗਰੀ ਤੁਰੰਤ ਪ੍ਰਭਾਵਿਤ ਹੋਵੇਗੀ।

optimized scope (ਜਿਸ ਵਿੱਚ functions, generators ਅਤੇ coroutines ਸ਼ਾਮਲ ਹਨ) ਵਿੱਚ, locals() ਦੀ ਹਰ ਕਾਲ ਇੱਕ ਨਵੀਂ dictionary ਵਾਪਸ ਕਰਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਫੰਕਸ਼ਨ ਦੇ local variables ਦੀਆਂ ਮੌਜੂਦਾ bindings ਅਤੇ ਕਿਸੇ ਵੀ nonlocal cell references ਦੀ ਜਾਣਕਾਰੀ ਹੁੰਦੀ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਵਾਪਸ ਕੀਤੀ dict ਰਾਹੀਂ ਕੀਤੀਆਂ name binding ਤਬਦੀਲੀਆਂ ਸੰਬੰਧਿਤ local variables ਜਾਂ nonlocal cell references ਵਿੱਚ ਵਾਪਸ ਨਹੀਂ ਲਿਖੀਆਂ ਜਾਂਦੀਆਂ, ਅਤੇ local variables ਜਾਂ nonlocal cell references ਨੂੰ assign, reassign ਜਾਂ delete ਕਰਨ ਨਾਲ ਪਹਿਲਾਂ ਵਾਪਸ ਕੀਤੀਆਂ dictionaries ਦੀ ਸਮੱਗਰੀ ਪ੍ਰਭਾਵਿਤ ਨਹੀਂ ਹੁੰਦੀ।

ਕਿਸੇ function, generator ਜਾਂ coroutine ਵਿੱਚ comprehension ਦੇ ਹਿੱਸੇ ਵਜੋਂ locals() ਨੂੰ ਕਾਲ ਕਰਨਾ ਉਸਨੂੰ enclosing scope ਵਿੱਚ ਕਾਲ ਕਰਨ ਦੇ ਬਰਾਬਰ ਹੈ, ਸਿਵਾਏ ਇਸਦੇ ਕਿ comprehension ਦੇ initialized iteration variables ਵੀ ਸ਼ਾਮਲ ਕੀਤੇ ਜਾਣਗੇ। ਹੋਰ scopes ਵਿੱਚ, ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਵਰਤਾਓ ਕਰਦਾ ਹੈ ਜਿਵੇਂ comprehension ਇੱਕ nested function ਵਜੋਂ ਚੱਲ ਰਹੀ ਹੋਵੇ।

generator expression ਦੇ ਹਿੱਸੇ ਵਜੋਂ locals() ਨੂੰ ਕਾਲ ਕਰਨਾ ਇਸਨੂੰ ਇੱਕ nested generator function ਵਿੱਚ ਕਾਲ ਕਰਨ ਦੇ ਬਰਾਬਰ ਹੈ।

Changed in version 3.12: ਕੰਪ੍ਰਿਹੈਂਸ਼ਨ ਵਿੱਚ locals() ਦੇ ਵਿਹਾਰ ਨੂੰ PEP 709 ਵਿੱਚ ਦਿੱਤੇ ਵੇਰਵੇ ਅਨੁਸਾਰ ਅਪਡੇਟ ਕੀਤਾ ਗਿਆ ਹੈ।

Changed in version 3.13: PEP 667 ਦੇ ਹਿੱਸੇ ਵਜੋਂ, ਇਸ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ ਮੈਪਿੰਗ ਆਬਜੈਕਟਾਂ ਵਿੱਚ ਤਬਦੀਲੀ ਕਰਨ ਦੇ ਨਿਯਮ ਹੁਣ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੇ ਗਏ ਹਨ। optimized scopes ਵਿੱਚ ਵਿਹਾਰ ਹੁਣ ਉੱਪਰ ਦਿੱਤੇ ਵੇਰਵੇ ਅਨੁਸਾਰ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ ਹੋਰ ਸਕੋਪਾਂ ਵਿੱਚ ਵਿਹਾਰ ਪਹਿਲਾਂ ਵਾਲੇ ਸੰਸਕਰਣਾਂ ਵਾਂਗ ਹੀ ਰਹਿੰਦਾ ਹੈ।

map(function, iterable, /, *iterables, strict=False)

ਹਰੇਕ iterable ਦੀ ਹਰ ਆਈਟਮ 'ਤੇ function ਲਾਗੂ ਕਰਨ ਵਾਲਾ ਇੱਕ ਇਟਰੇਟਰ ਵਾਪਸ ਕਰਦਾ ਹੈ ਅਤੇ ਨਤੀਜੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਜੇ ਵਾਧੂ iterables ਆਰਗੂਮੈਂਟ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ, ਤਾਂ function ਨੂੰ ਉੱਨੇ ਹੀ ਆਰਗੂਮੈਂਟ ਲੈਣੇ ਚਾਹੀਦੇ ਹਨ ਅਤੇ ਸਾਰੇ ਇਟਰੇਬਲਜ਼ ਦੀਆਂ ਆਈਟਮਾਂ 'ਤੇ ਸਮਾਂਤਰ ਤੌਰ 'ਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਤੋਂ ਵੱਧ ਇਟਰੇਬਲਜ਼ ਦੇ ਨਾਲ, ਇਟਰੇਟਰ ਉਦੋਂ ਰੁਕ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਸਭ ਤੋਂ ਛੋਟਾ ਇਟਰੇਬਲ exhausted ਹੋ ਜਾਂਦਾ ਹੈ। ਜੇ strict True ਹੈ ਅਤੇ ਕੋਈ ਇੱਕ ਇਟਰੇਬਲ ਬਾਕੀਆਂ ਤੋਂ ਪਹਿਲਾਂ ਖਤਮ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ValueError ਉਠਾਇਆ ਜਾਂਦਾ ਹੈ। ਜੇ ਫੰਕਸ਼ਨ ਦੇ ਇਨਪੁੱਟ ਪਹਿਲਾਂ ਹੀ ਆਰਗੂਮੈਂਟ ਟਿਊਪਲਾਂ ਵਿੱਚ ਵਿਵਸਥਿਤ ਕੀਤੇ ਹੋਏ ਹਨ, ਤਾਂ itertools.starmap() ਵੇਖੋ।

Changed in version 3.14: strict ਪੈਰਾਮੀਟਰ ਜੋੜਿਆ ਗਿਆ।

max(iterable, /, *, key=None)

max(iterable, /, *, default, key=None)

max(arg1, arg2, /, *args, key=None)

ਕਿਸੇ iterable ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਵੱਡੀ ਆਈਟਮ ਜਾਂ ਦੋ ਜਾਂ ਵੱਧ ਆਰਗੂਮੈਂਟਾਂ ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਵੱਡਾ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਜੇ ਇੱਕ positional argument ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ, ਤਾਂ ਉਹ ਇੱਕ iterable ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਉਸ iterable ਦੀ ਸਭ ਤੋਂ ਵੱਡੀ ਆਈਟਮ ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਜੇ ਦੋ ਜਾਂ ਵੱਧ positional arguments ਦਿੱਤੇ ਜਾਣ, ਤਾਂ ਉਨ੍ਹਾਂ ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਵੱਡਾ ਮੁੱਲ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਦੋ ਵਿਕਲਪਿਕ keyword-only arguments ਹਨ। key argument ਇੱਕ ਐਸਾ ਇੱਕ-ਆਰਗੂਮੈਂਟ ਕ੍ਰਮਬੱਧਤਾ ਫੰਕਸ਼ਨ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਜਿਵੇਂ list.sort() ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। default argument ਉਹ ਆਬਜੈਕਟ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਜੋ iterable ਖਾਲੀ ਹੋਣ 'ਤੇ ਵਾਪਸ ਕੀਤਾ ਜਾਵੇ। ਜੇ iterable ਖਾਲੀ ਹੋਵੇ ਅਤੇ default ਨਾ ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ, ਤਾਂ ValueError ਉਠਾਇਆ ਜਾਂਦਾ ਹੈ।

ਜੇ ਕਈ ਆਈਟਮਾਂ ਸਭ ਤੋਂ ਵੱਡੀਆਂ ਹੋਣ, ਤਾਂ ਫੰਕਸ਼ਨ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਮਿਲੀ ਆਈਟਮ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਹ sort-stability ਬਣਾਈ ਰੱਖਣ ਵਾਲੇ ਹੋਰ ਟੂਲਾਂ ਜਿਵੇਂ sorted(iterable, key=keyfunc, reverse=True)[0] ਅਤੇ heapq.nlargest(1, iterable, key=keyfunc) ਦੇ ਅਨੁਕੂਲ ਹੈ।

Changed in version 3.4: default keyword-only ਪੈਰਾਮੀਟਰ ਜੋੜਿਆ ਗਿਆ।

Changed in version 3.8: key None ਹੋ ਸਕਦਾ ਹੈ।

class memoryview(object)

ਦਿੱਤੇ ਗਏ argument ਤੋਂ ਬਣਿਆ ਇੱਕ "memory view" ਆਬਜੈਕਟ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ Memory Views ਵੇਖੋ।

min(iterable, /, *, key=None)

min(iterable, /, *, default, key=None)

min(arg1, arg2, /, *args, key=None)

ਕਿਸੇ iterable ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਛੋਟੀ ਆਈਟਮ ਜਾਂ ਦੋ ਜਾਂ ਵੱਧ ਆਰਗੂਮੈਂਟਾਂ ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਛੋਟਾ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਜੇ ਇੱਕ positional argument ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ, ਤਾਂ ਉਹ ਇੱਕ iterable ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਉਸ iterable ਦੀ ਸਭ ਤੋਂ ਛੋਟੀ ਆਈਟਮ ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਜੇ ਦੋ ਜਾਂ ਵੱਧ positional arguments ਦਿੱਤੇ ਜਾਣ, ਤਾਂ ਉਨ੍ਹਾਂ ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਛੋਟਾ ਮੁੱਲ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਦੋ ਵਿਕਲਪਿਕ keyword-only arguments ਹਨ। key argument ਇੱਕ ਐਸਾ ਇੱਕ-ਆਰਗੂਮੈਂਟ ਕ੍ਰਮਬੱਧਤਾ ਫੰਕਸ਼ਨ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਜਿਵੇਂ list.sort() ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। default argument ਉਹ ਆਬਜੈਕਟ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਜੋ iterable ਖਾਲੀ ਹੋਣ 'ਤੇ ਵਾਪਸ ਕੀਤਾ ਜਾਵੇ। ਜੇ iterable ਖਾਲੀ ਹੋਵੇ ਅਤੇ default ਨਾ ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ, ਤਾਂ ValueError ਉਠਾਇਆ ਜਾਂਦਾ ਹੈ।

ਜੇ ਕਈ ਆਈਟਮਾਂ ਸਭ ਤੋਂ ਛੋਟੀਆਂ ਹੋਣ, ਤਾਂ ਫੰਕਸ਼ਨ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਮਿਲੀ ਆਈਟਮ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਹ sort-stability ਬਣਾਈ ਰੱਖਣ ਵਾਲੇ ਹੋਰ ਟੂਲਾਂ ਜਿਵੇਂ sorted(iterable, key=keyfunc)[0] ਅਤੇ heapq.nsmallest(1, iterable, key=keyfunc) ਦੇ ਅਨੁਕੂਲ ਹੈ।

Changed in version 3.4: default keyword-only ਪੈਰਾਮੀਟਰ ਜੋੜਿਆ ਗਿਆ।

Changed in version 3.8: key None ਹੋ ਸਕਦਾ ਹੈ।

next(iterator, /)

next(iterator, default, /)

iterator ਦੇ __next__() ਢੰਗ ਨੂੰ ਕਾਲ ਕਰਕੇ ਉਸ ਵਿੱਚੋਂ ਅਗਲੀ ਆਈਟਮ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ। ਜੇ default ਦਿੱਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਜੇ ਇਟਰੇਟਰ exhausted ਹੋ ਗਿਆ ਹੋਵੇ ਤਾਂ ਇਹ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਨਹੀਂ ਤਾਂ StopIteration ਉਠਾਇਆ ਜਾਂਦਾ ਹੈ।

class object

ਇਹ ਹੋਰ ਸਾਰੀਆਂ classes ਦੀ ਅੰਤਿਮ base class ਹੈ। ਇਸ ਵਿੱਚ ਉਹ methods ਹਨ ਜੋ Python classes ਦੇ ਸਾਰੇ instances ਲਈ ਸਾਂਝੀਆਂ ਹੁੰਦੀਆਂ ਹਨ। ਜਦੋਂ constructor ਨੂੰ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਇਹ ਇੱਕ ਨਵਾਂ featureless object ਵਾਪਸ ਕਰਦਾ ਹੈ। Constructor ਕੋਈ ਵੀ arguments ਸਵੀਕਾਰ ਨਹੀਂ ਕਰਦਾ।

Note

object ਦੇ instances ਕੋਲ __dict__ attribute ਨਹੀਂ ਹੁੰਦਾ, ਇਸ ਲਈ ਤੁਸੀਂ object ਦੇ instance ਨੂੰ ਮਨਮਾਨੇ attributes assign ਨਹੀਂ ਕਰ ਸਕਦੇ।

oct(integer, /)

ਇੱਕ ਪੂਰਨ ਅੰਕ ਨੂੰ "0o" ਪ੍ਰੀਫਿਕਸ ਵਾਲੀ octal ਸਤਰ ਵਿੱਚ ਬਦਲੋ। ਨਤੀਜਾ ਇੱਕ ਵੈਧ Python expression ਹੁੰਦਾ ਹੈ। ਜੇ integer ਇੱਕ Python int ਆਬਜੈਕਟ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਸ ਵਿੱਚ __index__() ਮੈਥਡ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਇੱਕ ਪੂਰਨ ਅੰਕ ਵਾਪਸ ਕਰੇ। ਉਦਾਹਰਨ ਲਈ:

>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'

ਜੇ ਤੁਸੀਂ ਇੱਕ ਪੂਰਨ ਅੰਕ ਨੂੰ "0o" ਪ੍ਰੀਫਿਕਸ ਸਮੇਤ ਜਾਂ ਬਿਨਾਂ octal ਸਤਰ ਵਿੱਚ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਕਿਸੇ ਵੀ ਤਰੀਕੇ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।

>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ format() ਵੀ ਵੇਖੋ।

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

file ਨੂੰ ਖੋਲ੍ਹੋ ਅਤੇ ਇਸ ਨਾਲ ਸੰਬੰਧਿਤ file object ਵਾਪਸ ਕਰੋ। ਜੇ ਫਾਈਲ ਨਹੀਂ ਖੁੱਲ ਸਕਦੀ, ਤਾਂ OSError ਉਠਾਇਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਦੇ ਹੋਰ ਉਦਾਹਰਨਾਂ ਲਈ ਫਾਈਲਾਂ ਨੂੰ ਪੜ੍ਹਨਾ ਅਤੇ ਲਿਖਣਾ ਵੇਖੋ।

file ਇੱਕ path-like object ਹੈ ਜੋ ਖੋਲ੍ਹੀ ਜਾਣ ਵਾਲੀ ਫਾਈਲ ਦਾ path (absolute ਜਾਂ ਮੌਜੂਦਾ working directory ਦੇ ਸਬੰਧ ਵਿੱਚ relative) ਦਿੰਦਾ ਹੈ, ਜਾਂ wrap ਕੀਤੀ ਜਾਣ ਵਾਲੀ ਫਾਈਲ ਦਾ integer file descriptor ਹੋ ਸਕਦਾ ਹੈ। (ਜੇ file descriptor ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ, ਤਾਂ ਵਾਪਸ ਕੀਤਾ I/O ਆਬਜੈਕਟ ਬੰਦ ਹੋਣ ਤੇ ਇਹ ਵੀ ਬੰਦ ਹੋ ਜਾਵੇਗਾ, ਜਦ ਤੱਕ closefd ਨੂੰ False ਨਾ ਕੀਤਾ ਗਿਆ ਹੋਵੇ।)

mode ਇੱਕ ਵਿਕਲਪਿਕ ਸਤਰ ਹੈ ਜੋ ਉਸ ਮੋਡ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਫਾਈਲ ਖੋਲ੍ਹੀ ਜਾਂਦੀ ਹੈ। ਇਸਦਾ ਡਿਫਾਲਟ ਮੁੱਲ 'r' ਹੈ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਟੈਕਸਟ ਮੋਡ ਵਿੱਚ ਪੜ੍ਹਨ ਲਈ ਖੋਲ੍ਹਣਾ। ਹੋਰ ਆਮ ਮੁੱਲ ਹਨ ਲਿਖਣ ਲਈ 'w' (ਜੇ ਫਾਈਲ ਪਹਿਲਾਂ ਹੀ ਮੌਜੂਦ ਹੈ ਤਾਂ ਇਸਦੀ ਸਮੱਗਰੀ ਨੂੰ ਖਾਲੀ ਕਰ ਦਿੰਦਾ ਹੈ), ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਬਣਾਉਣ ਲਈ 'x', ਅਤੇ ਅੰਤ ਵਿੱਚ ਜੋੜਨ ਲਈ 'a' (ਜੋ ਕੁਝ Unix ਸਿਸਟਮਾਂ 'ਤੇ ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਮੌਜੂਦਾ seek ਸਥਿਤੀ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ ਸਾਰੀਆਂ ਲਿਖਤਾਂ ਫਾਈਲ ਦੇ ਅੰਤ ਵਿੱਚ ਜੋੜੀਆਂ ਜਾਂਦੀਆਂ ਹਨ)। ਟੈਕਸਟ ਮੋਡ ਵਿੱਚ, ਜੇ encoding ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਡਿਫਾਲਟ ਰੂਪ ਵਿੱਚ UTF-8 ਵਰਤੀ ਜਾਂਦੀ ਹੈ; ਜੇ Python UTF-8 Mode ਅਸਮਰੱਥ ਹੈ, ਤਾਂ ਮੌਜੂਦਾ ਲੋਕੇਲ ਇਨਕੋਡਿੰਗ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ locale.getencoding() ਨੂੰ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। (ਕੱਚੇ ਬਾਈਟ ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਲਈ ਬਾਈਨਰੀ ਮੋਡ ਵਰਤੋ ਅਤੇ encoding ਨਿਰਧਾਰਤ ਨਾ ਕਰੋ।) ਉਪਲਬਧ ਮੋਡ ਹਨ:

ਅੱਖਰ	ਅਰਥ
'r'	ਪੜ੍ਹਨ ਲਈ ਖੋਲ੍ਹੋ (ਡਿਫਾਲਟ)
'w'	ਲਿਖਣ ਲਈ ਖੋਲ੍ਹੋ, ਪਹਿਲਾਂ ਫਾਈਲ ਨੂੰ truncate ਕਰੋ
'x'	ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਬਣਾਉਣ ਲਈ ਖੋਲ੍ਹੋ; ਜੇ ਫਾਈਲ ਪਹਿਲਾਂ ਮੌਜੂਦ ਹੋਵੇ ਤਾਂ ਅਸਫਲ ਹੋਵੇ
'a'	ਲਿਖਣ ਲਈ ਖੋਲ੍ਹੋ; ਜੇ ਫਾਈਲ ਮੌਜੂਦ ਹੋਵੇ ਤਾਂ ਅੰਤ ਵਿੱਚ ਜੋੜੋ
'b'	ਬਾਈਨਰੀ ਮੋਡ
't'	ਟੈਕਸਟ ਮੋਡ (ਡਿਫਾਲਟ)
'+'	ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਖੋਲ੍ਹੋ (ਪੜ੍ਹਨਾ ਅਤੇ ਲਿਖਣਾ)

ਡਿਫਾਲਟ ਮੋਡ 'r' ਹੈ (ਟੈਕਸਟ ਪੜ੍ਹਨ ਲਈ ਖੋਲ੍ਹਣਾ, ਜੋ 'rt' ਦਾ ਸਮਾਨਾਰਥੀ ਹੈ)। 'w+' ਅਤੇ 'w+b' ਮੋਡ ਫਾਈਲ ਨੂੰ ਖੋਲ੍ਹਦੇ ਅਤੇ truncate ਕਰਦੇ ਹਨ। 'r+' ਅਤੇ 'r+b' ਮੋਡ ਫਾਈਲ ਨੂੰ ਬਿਨਾਂ truncate ਕੀਤੇ ਖੋਲ੍ਹਦੇ ਹਨ।

ਜਿਵੇਂ Overview ਵਿੱਚ ਦੱਸਿਆ ਗਿਆ ਹੈ, Python ਬਾਈਨਰੀ ਅਤੇ ਟੈਕਸਟ I/O ਵਿੱਚ ਫ਼ਰਕ ਕਰਦਾ ਹੈ। ਬਾਈਨਰੀ ਮੋਡ ਵਿੱਚ ਖੋਲ੍ਹੀਆਂ ਗਈਆਂ ਫਾਈਲਾਂ (mode ਆਰਗੂਮੈਂਟ ਵਿੱਚ 'b' ਸਮੇਤ) ਬਿਨਾਂ ਕਿਸੇ ਡੀਕੋਡਿੰਗ ਦੇ ਸਮੱਗਰੀ ਨੂੰ bytes ਵਸਤੂਆਂ ਵਜੋਂ ਵਾਪਸ ਕਰਦੀਆਂ ਹਨ। ਟੈਕਸਟ ਮੋਡ ਵਿੱਚ (ਡਿਫਾਲਟ ਰੂਪ ਵਿੱਚ, ਜਾਂ ਜਦੋਂ mode ਆਰਗੂਮੈਂਟ ਵਿੱਚ 't' ਸ਼ਾਮਲ ਹੋਵੇ), ਫਾਈਲ ਦੀ ਸਮੱਗਰੀ str ਵਜੋਂ ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਸ ਦੇ ਬਾਈਟਾਂ ਨੂੰ ਪਹਿਲਾਂ ਡਿਫਾਲਟ ਇਨਕੋਡਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਜਾਂ, ਜੇ ਦਿੱਤੀ ਗਈ ਹੋਵੇ, ਤਾਂ ਨਿਰਧਾਰਤ encoding ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡੀਕੋਡ ਕੀਤਾ ਗਿਆ ਹੁੰਦਾ ਹੈ।

Note

Python ਟੈਕਸਟ ਫਾਈਲਾਂ ਬਾਰੇ underlying operating system ਦੀ ਧਾਰਣਾ 'ਤੇ ਨਿਰਭਰ ਨਹੀਂ ਕਰਦਾ; ਸਾਰੀ ਪ੍ਰਕਿਰਿਆ Python ਖੁਦ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਇਹ platform-independent ਹੈ।

buffering ਇੱਕ ਵਿਕਲਪਿਕ integer ਹੈ ਜੋ buffering policy ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। Buffering ਨੂੰ ਬੰਦ ਕਰਨ ਲਈ 0 ਦਿਓ (ਇਹ ਕੇਵਲ binary mode ਵਿੱਚ ਮਨਜ਼ੂਰ ਹੈ), line buffering ਚੁਣਨ ਲਈ 1 ਦਿਓ (ਇਹ ਸਿਰਫ਼ text mode ਵਿੱਚ ਲਿਖਣ ਸਮੇਂ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ), ਅਤੇ fixed-size chunk buffer ਦਾ ਆਕਾਰ bytes ਵਿੱਚ ਦਰਸਾਉਣ ਲਈ 1 ਤੋਂ ਵੱਡਾ integer ਦਿਓ। ਧਿਆਨ ਰਹੇ ਕਿ ਇਸ ਤਰੀਕੇ ਨਾਲ ਦਿੱਤਾ buffer size binary buffered I/O 'ਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ, ਪਰ TextIOWrapper (ਅਰਥਾਤ mode='r+' ਨਾਲ ਖੋਲ੍ਹੀਆਂ ਫ਼ਾਈਲਾਂ) ਦੀ buffering ਵੱਖਰੀ ਹੁੰਦੀ ਹੈ। TextIOWrapper ਵਿੱਚ buffering ਅਯੋਗ ਕਰਨ ਲਈ io.TextIOWrapper.reconfigure() ਦਾ write_through flag ਵਰਤਣ ਬਾਰੇ ਵਿਚਾਰ ਕਰੋ। ਜਦੋਂ buffering argument ਨਹੀਂ ਦਿੱਤਾ ਜਾਂਦਾ, ਤਾਂ ਮੂਲ buffering policy ਹੇਠਾਂ ਦਿੱਤੇ ਤਰੀਕੇ ਨਾਲ ਕੰਮ ਕਰਦੀ ਹੈ:

• Binary ਫਾਈਲਾਂ ਨੂੰ fixed-size chunks ਵਿੱਚ buffer ਕੀਤਾ ਜਾਂਦਾ ਹੈ; ਜਦੋਂ device block size ਉਪਲਬਧ ਹੋਵੇ ਤਾਂ buffer ਦਾ ਆਕਾਰ max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE) ਹੁੰਦਾ ਹੈ। ਜ਼ਿਆਦਾਤਰ ਸਿਸਟਮਾਂ ਵਿੱਚ buffer ਆਮ ਤੌਰ 'ਤੇ 128 kilobytes ਦਾ ਹੁੰਦਾ ਹੈ।

• "Interactive" ਟੈਕਸਟ ਫਾਈਲਾਂ (ਜਿਨ੍ਹਾਂ ਲਈ isatty() True ਵਾਪਸ ਕਰਦਾ ਹੈ) line buffering ਵਰਤਦੀਆਂ ਹਨ। ਹੋਰ ਟੈਕਸਟ ਫਾਈਲਾਂ ਉਹੀ ਨੀਤੀ ਵਰਤਦੀਆਂ ਹਨ ਜੋ ਉੱਪਰ binary ਫਾਈਲਾਂ ਲਈ ਦਰਸਾਈ ਗਈ ਹੈ।

encoding ਫਾਈਲ ਨੂੰ ਡੀਕੋਡ ਜਾਂ ਇਨਕੋਡ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਣ ਵਾਲੀ ਇਨਕੋਡਿੰਗ ਦਾ ਨਾਮ ਹੈ। ਇਸਦੀ ਵਰਤੋਂ ਸਿਰਫ਼ ਟੈਕਸਟ ਮੋਡ ਵਿੱਚ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ। ਡਿਫਾਲਟ ਇਨਕੋਡਿੰਗ UTF-8 ਹੈ; ਜੇ Python UTF-8 Mode ਅਸਮਰੱਥ ਹੈ, ਤਾਂ ਡਿਫਾਲਟ ਪਲੇਟਫਾਰਮ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ (ਜੋ ਵੀ locale.getencoding() ਵਾਪਸ ਕਰਦਾ ਹੈ)। Python ਦੁਆਰਾ ਸਮਰਥਿਤ ਕੋਈ ਵੀ text encoding ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਅਤੇ encoding="locale" ਮੌਜੂਦਾ ਲੋਕੇਲ ਇਨਕੋਡਿੰਗ ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਦਰਸਾਉਂਦਾ ਹੈ। ਸਮਰਥਿਤ ਇਨਕੋਡਿੰਗਾਂ ਦੀ ਸੂਚੀ ਲਈ codecs ਮੋਡੀਊਲ ਵੇਖੋ।

errors ਇੱਕ ਵਿਕਲਪੀ string ਹੈ ਜੋ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ encoding ਅਤੇ decoding ਗਲਤੀਆਂ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਿਆ ਜਾਣਾ ਹੈ—ਇਸਨੂੰ binary mode ਵਿੱਚ ਵਰਤਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ। ਕਈ ਮਿਆਰੀ error handlers ਉਪਲਬਧ ਹਨ, ਹਾਲਾਂਕਿ codecs.register_error() ਨਾਲ ਰਜਿਸਟਰ ਕੀਤਾ ਗਿਆ ਕੋਈ ਵੀ error handling ਨਾਮ ਵੀ ਵੈਧ ਹੈ। ਮਿਆਰੀ ਨਾਮ Error Handlers ਵਿੱਚ ਵੇਖੇ ਜਾ ਸਕਦੇ ਹਨ।

newline ਇਹ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ stream ਤੋਂ newline ਅੱਖਰਾਂ ਨੂੰ ਕਿਵੇਂ parse ਕੀਤਾ ਜਾਵੇ। ਇਹ None, '', '\n', '\r' ਜਾਂ '\r\n' ਹੋ ਸਕਦਾ ਹੈ। ਇਹ ਹੇਠਾਂ ਦਿੱਤੇ ਅਨੁਸਾਰ ਕੰਮ ਕਰਦਾ ਹੈ:

• ਸਟ੍ਰੀਮ ਤੋਂ input ਪੜ੍ਹਦੇ ਸਮੇਂ, ਜੇ newline None ਹੋਵੇ, ਤਾਂ universal newlines mode ਚਾਲੂ ਹੋ ਜਾਂਦੀ ਹੈ। Input ਦੀਆਂ ਲਾਈਨਾਂ '\n', '\r' ਜਾਂ '\r\n' ਨਾਲ ਖਤਮ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਅਤੇ caller ਨੂੰ ਵਾਪਸ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇਨ੍ਹਾਂ ਨੂੰ '\n' ਵਿੱਚ ਬਦਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਜੇ ਇਸਦੀ value '' ਹੋਵੇ, ਤਾਂ universal newlines mode ਚਾਲੂ ਰਹਿੰਦੀ ਹੈ, ਪਰ line endings ਬਿਨਾਂ ਕਿਸੇ ਤਬਦੀਲੀ ਦੇ caller ਨੂੰ ਵਾਪਸ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਜੇ ਇਸਦੀ ਕੋਈ ਹੋਰ ਵੈਧ value ਹੋਵੇ, ਤਾਂ input lines ਸਿਰਫ਼ ਦਿੱਤੀ ਗਈ string ਨਾਲ ਹੀ ਸਮਾਪਤ ਮੰਨੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਅਤੇ line ending ਬਿਨਾਂ ਤਬਦੀਲੀ ਦੇ ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

• ਸਟ੍ਰੀਮ ਵਿੱਚ output ਲਿਖਦੇ ਸਮੇਂ, ਜੇ newline None ਹੋਵੇ, ਤਾਂ ਲਿਖੇ ਗਏ ਸਾਰੇ '\n' ਅੱਖਰ system ਦੇ ਮੂਲ line separator os.linesep ਵਿੱਚ ਬਦਲੇ ਜਾਂਦੇ ਹਨ। ਜੇ newline '' ਜਾਂ '\n' ਹੋਵੇ, ਤਾਂ ਕੋਈ ਤਬਦੀਲੀ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ। ਜੇ newline ਦੀ ਕੋਈ ਹੋਰ ਵੈਧ value ਹੋਵੇ, ਤਾਂ ਲਿਖੇ ਗਏ '\n' ਅੱਖਰ ਦਿੱਤੀ ਗਈ string ਵਿੱਚ ਬਦਲੇ ਜਾਂਦੇ ਹਨ।

ਜੇ closefd False ਹੋਵੇ ਅਤੇ filename ਦੀ ਬਜਾਏ file descriptor ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ, ਤਾਂ ਫ਼ਾਈਲ ਬੰਦ ਹੋਣ 'ਤੇ ਅੰਦਰੂਨੀ file descriptor ਖੁੱਲ੍ਹਾ ਹੀ ਰਹੇਗਾ। ਜੇ filename ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ, ਤਾਂ closefd ਦਾ True ਹੋਣਾ ਲਾਜ਼ਮੀ ਹੈ (ਜੋ ਮੂਲ ਮੁੱਲ ਹੈ); ਨਹੀਂ ਤਾਂ ਇੱਕ error ਉਠਾਈ ਜਾਵੇਗੀ।

opener ਵਜੋਂ ਇੱਕ callable ਦੇ ਕੇ custom opener ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਫਿਰ file object ਲਈ ਅੰਦਰੂਨੀ file descriptor, opener ਨੂੰ (file, flags) ਨਾਲ ਕਾਲ ਕਰਕੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। opener ਨੂੰ ਇੱਕ ਖੁੱਲ੍ਹਾ file descriptor ਵਾਪਸ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ (ਜੇ os.open ਨੂੰ opener ਵਜੋਂ ਦਿੱਤਾ ਜਾਵੇ, ਤਾਂ ਇਸਦਾ ਵਿਵਹਾਰ None ਦੇਣ ਦੇ ਸਮਾਨ ਹੁੰਦਾ ਹੈ)।

ਨਵੀਂ ਬਣਾਈ ਗਈ ਫਾਈਲ non-inheritable ਹੁੰਦੀ ਹੈ।

ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਨ os.open() ਫੰਕਸ਼ਨ ਦੇ dir_fd parameter ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਸੇ ਦਿੱਤੀ ਗਈ directory ਦੇ ਸਬੰਧ ਵਿੱਚ ਇੱਕ ਫ਼ਾਈਲ ਖੋਲ੍ਹਦੀ ਹੈ:

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor

open() ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਵਾਪਸ ਕੀਤਾ ਗਿਆ file object ਦਾ ਪ੍ਰਕਾਰ mode 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਜਦੋਂ open() ਨੂੰ text mode ('w', 'r', 'wt', 'rt' ਆਦਿ) ਵਿੱਚ ਫ਼ਾਈਲ ਖੋਲ੍ਹਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ io.TextIOBase ਦੀ ਇੱਕ subclass (ਖਾਸ ਤੌਰ 'ਤੇ io.TextIOWrapper) ਵਾਪਸ ਕਰਦਾ ਹੈ। ਜਦੋਂ buffering ਸਮੇਤ binary mode ਵਿੱਚ ਫ਼ਾਈਲ ਖੋਲੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਵਾਪਸ ਕੀਤੀ ਗਈ class io.BufferedIOBase ਦੀ subclass ਹੁੰਦੀ ਹੈ। ਸਹੀ class mode ਦੇ ਅਨੁਸਾਰ ਬਦਲਦੀ ਹੈ: read binary mode ਵਿੱਚ io.BufferedReader, write ਅਤੇ append binary modes ਵਿੱਚ io.BufferedWriter, ਅਤੇ read/write mode ਵਿੱਚ io.BufferedRandom ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਜਦੋਂ buffering ਅਯੋਗ ਹੁੰਦੀ ਹੈ, ਤਾਂ raw stream io.FileIO, ਜੋ io.RawIOBase ਦੀ subclass ਹੈ, ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਫ਼ਾਈਲ ਸੰਭਾਲਣ ਨਾਲ ਸੰਬੰਧਿਤ modules ਵੀ ਵੇਖੋ, ਜਿਵੇਂ fileinput, io (ਜਿੱਥੇ open() ਪਰਿਭਾਸ਼ਿਤ ਹੈ), os, os.path, tempfile ਅਤੇ shutil।

ਆਰਗੂਮੈਂਟ path, mode ਅਤੇ flags ਨਾਲ auditing event open ਉਤਪੰਨ ਕਰਦਾ ਹੈ।

mode ਅਤੇ flags ਆਰਗੂਮੈਂਟ ਮੂਲ ਕਾਲ ਤੋਂ ਸੋਧੇ ਗਏ ਜਾਂ ਅਨੁਮਾਨਿਤ ਕੀਤੇ ਗਏ ਹੋ ਸਕਦੇ ਹਨ।

Changed in version 3.3:

• opener ਪੈਰਾਮੀਟਰ ਜੋੜਿਆ ਗਿਆ।

• 'x' ਮੋਡ ਜੋੜਿਆ ਗਿਆ।

• ਪਹਿਲਾਂ IOError ਉਤਪੰਨ ਕੀਤਾ ਜਾਂਦਾ ਸੀ, ਹੁਣ ਇਹ OSError ਦਾ alias ਹੈ।

• ਜੇ exclusive creation mode ('x') ਵਿੱਚ ਖੋਲੀ ਜਾਣ ਵਾਲੀ ਫਾਈਲ ਪਹਿਲਾਂ ਹੀ ਮੌਜੂਦ ਹੋਵੇ, ਤਾਂ ਹੁਣ FileExistsError ਉਤਪੰਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

Changed in version 3.4:

• ਫਾਈਲ ਹੁਣ non-inheritable ਹੈ।

Changed in version 3.5:

• ਜੇ system call ਵਿੱਚ ਰੁਕਾਵਟ ਆ ਜਾਵੇ ਅਤੇ signal handler ਕੋਈ exception ਨਾ ਉਠਾਏ, ਤਾਂ ਹੁਣ ਇਹ ਫੰਕਸ਼ਨ InterruptedError exception ਉਠਾਉਣ ਦੀ ਬਜਾਏ ਉਸ system call ਨੂੰ ਮੁੜ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ (ਕਾਰਨ ਲਈ PEP 475 ਵੇਖੋ)।

• 'namereplace' error handler ਜੋੜਿਆ ਗਿਆ।

Changed in version 3.6:

• os.PathLike ਨੂੰ ਲਾਗੂ ਕਰਨ ਵਾਲੇ ਆਬਜੈਕਟਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨ ਲਈ ਸਮਰਥਨ ਜੋੜਿਆ ਗਿਆ।

• Windows 'ਤੇ, ਇੱਕ ਕੰਸੋਲ ਬਫਰ ਖੋਲ੍ਹਣ ਨਾਲ io.RawIOBase ਦੀ ਕੋਈ ਹੋਰ ਉਪ-ਕਲਾਸ ਵਾਪਸ ਆ ਸਕਦੀ ਹੈ, ਨਾ ਕਿ ਸਿਰਫ਼ io.FileIO ।

Changed in version 3.11: 'U' ਮੋਡ ਹਟਾ ਦਿੱਤਾ ਗਿਆ ਹੈ।

Changed in version 3.15: UTF-8 ਹੁਣ ਪਲੇਟਫਾਰਮ-ਨਿਰਭਰ ਲੋਕੇਲ ਇਨਕੋਡਿੰਗ ਦੀ ਬਜਾਏ ਡਿਫਾਲਟ ਇਨਕੋਡਿੰਗ ਹੈ (PEP 686)।

ord(character, /)

ਕਿਸੇ ਅੱਖਰ ਦਾ ordinal ਮੁੱਲ ਵਾਪਸ ਕਰੋ।

ਜੇ argument ਇੱਕ ਅੱਖਰ ਵਾਲੀ string ਹੈ, ਤਾਂ ਉਸ ਅੱਖਰ ਦਾ Unicode code point ਵਾਪਸ ਕਰੋ। ਉਦਾਹਰਨ ਲਈ, ord('a') integer 97 ਵਾਪਸ ਕਰਦਾ ਹੈ ਅਤੇ ord('€') (Euro ਚਿੰਨ੍ਹ) 8364 ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਹ chr() ਦਾ ਉਲਟ ਹੈ।

ਜੇ ਆਰਗੂਮੈਂਟ ਲੰਬਾਈ 1 ਵਾਲਾ bytes ਜਾਂ bytearray ਆਬਜੈਕਟ ਹੋਵੇ, ਤਾਂ ਉਸਦਾ ਇਕੱਲਾ ਬਾਈਟ ਮੁੱਲ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ord(b'a') ਪੂਰਨ ਅੰਕ 97 ਵਾਪਸ ਕਰਦਾ ਹੈ।

pow(base, exp, mod=None)

base ਨੂੰ exp ਘਾਤ ਤੱਕ ਉਠਾਇਆ ਹੋਇਆ ਮੁੱਲ ਵਾਪਸ ਕਰੋ; ਜੇ mod ਦਿੱਤਾ ਹੋਵੇ, ਤਾਂ base ਨੂੰ exp ਘਾਤ ਤੱਕ ਉਠਾ ਕੇ ਉਸਦਾ modulo mod ਵਾਪਸ ਕਰੋ (ਇਹ pow(base, exp) % mod ਨਾਲੋਂ ਵੱਧ ਕੁਸ਼ਲਤਾ ਨਾਲ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ)। ਦੋ-argument ਰੂਪ pow(base, exp) power operator base**exp ਦੇ ਬਰਾਬਰ ਹੈ।

ਜਦੋਂ ਦਲੀਲਾਂ ਮਿਸ਼ਰਤ ਓਪਰੇਂਡ ਕਿਸਮਾਂ ਵਾਲੀਆਂ ਅੰਕੜਾ ਕਿਸਮਾਂ ਵਿੱਚ ਹੁੰਦੀਆਂ ਹਨ, ਤਾਂ ਦੋ-ਅੰਕੜਾ ਗਣਿਤਿਕ ਓਪਰੇਟਰਾਂ ਲਈ ਕੋਰਸ਼ਨ ਨਿਯਮ ਲਾਗੂ ਹੁੰਦੇ ਹਨ। int ਓਪਰੇਂਡਾਂ ਲਈ, ਨਤੀਜੇ ਦੀ ਕਿਸਮ ਓਪਰੇਂਡਾਂ ਦੀ ਕਿਸਮ (ਕੋਰਸ਼ਨ ਤੋਂ ਬਾਅਦ) ਦੇ ਬਰਾਬਰ ਹੁੰਦੀ ਹੈ, ਜਦ ਤੱਕ ਦੂਜੀ ਦਲੀਲ ਨਕਾਰਾਤਮਕ ਨਾ ਹੋਵੇ; ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਸਾਰੀਆਂ ਦਲੀਲਾਂ ਫਲੋਟ ਵਿੱਚ ਬਦਲ ਦਿੱਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਅਤੇ ਫਲੋਟ ਨਤੀਜਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, pow(10, 2) 100 ਵਾਪਸ ਕਰਦਾ ਹੈ, ਪਰ pow(10, -2) 0.01 ਵਾਪਸ ਕਰਦਾ ਹੈ। int ਜਾਂ float ਕਿਸਮ ਦੇ ਨਕਾਰਾਤਮਕ ਬੇਸ ਅਤੇ ਗੈਰ-ਸੰਪੂਰਨ ਐਕਸਪੋਨੈਂਟ ਲਈ, ਇੱਕ ਕੰਪਲੈਕਸ ਨਤੀਜਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, pow(-9, 0.5) 3j ਦੇ ਨੇੜੇ ਇੱਕ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਜਦਕਿ, int ਜਾਂ float ਕਿਸਮ ਦੇ ਨਕਾਰਾਤਮਕ ਬੇਸ ਅਤੇ ਸੰਪੂਰਨ ਐਕਸਪੋਨੈਂਟ ਲਈ, ਇੱਕ ਫਲੋਟ ਨਤੀਜਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, pow(-9, 2.0) 81.0 ਵਾਪਸ ਕਰਦਾ ਹੈ।

int operands base ਅਤੇ exp ਲਈ, ਜੇ mod ਦਿੱਤਾ ਹੋਵੇ, ਤਾਂ mod ਵੀ integer ਕਿਸਮ ਦਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਇਸਦੀ value ਸਿਫ਼ਰ ਨਹੀਂ ਹੋਣੀ ਚਾਹੀਦੀ। ਜੇ mod ਦਿੱਤਾ ਹੋਵੇ ਅਤੇ exp negative ਹੋਵੇ, ਤਾਂ base ਅਤੇ mod ਆਪਸ ਵਿੱਚ relatively prime ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ। ਉਸ ਹਾਲਤ ਵਿੱਚ pow(inv_base, -exp, mod) ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਿੱਥੇ inv_base, mod ਦੇ ਸਬੰਧ ਵਿੱਚ base ਦਾ modular inverse ਹੁੰਦਾ ਹੈ।

ਇੱਥੇ 38 ਨੂੰ 97 ਮਾਡੀਊਲੋ 'ਤੇ ਇਨਵਰਸ ਕੰਪਿਊਟ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੈ

>>> pow(38, -1, mod=97)
23
>>> 23 * 38 % 97 == 1
True

Changed in version 3.8: int operands ਲਈ, pow ਦਾ ਤਿੰਨ-argument ਰੂਪ ਹੁਣ ਦੂਜੇ argument ਨੂੰ negative ਹੋਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ, ਜਿਸ ਨਾਲ modular inverses ਦੀ ਗਿਣਤੀ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

Changed in version 3.8: ਹੁਣ keyword arguments ਦੀ ਇਜਾਜ਼ਤ ਹੈ। ਪਹਿਲਾਂ ਸਿਰਫ positional arguments ਹੀ ਸਮਰਥਿਤ ਸਨ।

print(*objects, sep=' ', end='\n', file=None, flush=False)

objects ਨੂੰ file ਟੈਕਸਟ ਸਟ੍ਰੀਮ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ, ਜਿੱਥੇ ਉਹ sep ਨਾਲ ਵੱਖ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ end ਨਾਲ ਸਮਾਪਤ ਹੁੰਦੇ ਹਨ। sep, end, file ਅਤੇ flush, ਜੇ ਦਿੱਤੇ ਜਾਣ, ਤਾਂ keyword arguments ਵਜੋਂ ਹੀ ਦਿੱਤੇ ਜਾਣੇ ਚਾਹੀਦੇ ਹਨ।

ਸਾਰੇ non-keyword arguments ਨੂੰ str() ਦੀ ਤਰ੍ਹਾਂ strings ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਸਟ੍ਰੀਮ ਵਿੱਚ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ, ਜਿੱਥੇ ਉਹ sep ਨਾਲ ਵੱਖ ਹੁੰਦੇ ਹਨ ਅਤੇ end ਨਾਲ ਸਮਾਪਤ ਹੁੰਦੇ ਹਨ। sep ਅਤੇ end ਦੋਵੇਂ strings ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ; ਇਹ None ਵੀ ਹੋ ਸਕਦੇ ਹਨ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਮੂਲ ਮੁੱਲ ਵਰਤੇ ਜਾਣ। ਜੇ objects ਨਾ ਦਿੱਤੇ ਜਾਣ, ਤਾਂ print() ਸਿਰਫ਼ end ਲਿਖੇਗਾ।

file argument ਇੱਕ ਅਜਿਹਾ object ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜਿਸ ਵਿੱਚ write(string) method ਹੋਵੇ। ਜੇ ਇਹ ਮੌਜੂਦ ਨਾ ਹੋਵੇ ਜਾਂ None ਹੋਵੇ, ਤਾਂ sys.stdout ਵਰਤਿਆ ਜਾਵੇਗਾ। ਕਿਉਂਕਿ ਪ੍ਰਿੰਟ ਕੀਤੇ arguments ਨੂੰ text strings ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ, ਇਸ ਲਈ print() ਨੂੰ binary mode file objects ਨਾਲ ਨਹੀਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ। ਉਨ੍ਹਾਂ ਲਈ file.write(...) ਵਰਤੋ।

ਆਉਟਪੁੱਟ buffering ਆਮ ਤੌਰ 'ਤੇ file ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਪਰ ਜੇ flush true ਹੋਵੇ, ਤਾਂ stream ਨੂੰ ਜ਼ਬਰਦਸਤੀ flush ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

Changed in version 3.3: flush keyword argument ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ।

class property(fget=None, fset=None, fdel=None, doc=None)

ਇੱਕ property ਗੁਣ ਵਾਪਸ ਕਰਦਾ ਹੈ।

fget attribute ਦਾ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ ਹੈ। fset attribute ਦਾ ਮੁੱਲ ਸੈੱਟ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ ਹੈ। fdel attribute ਦਾ ਮੁੱਲ ਮਿਟਾਉਣ ਲਈ ਫੰਕਸ਼ਨ ਹੈ। doc attribute ਲਈ docstring ਬਣਾਉਂਦਾ ਹੈ।

ਇੱਕ ਆਮ ਵਰਤੋਂ ਇਹ ਹੈ ਕਿ ਇੱਕ ਪ੍ਰਬੰਧਿਤ ਗੁਣ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇ x:

class C:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")

ਜੇ c, C ਦਾ ਇੱਕ instance ਹੈ, ਤਾਂ c.x getter ਨੂੰ ਕਾਲ ਕਰੇਗਾ, c.x = value setter ਨੂੰ ਕਾਲ ਕਰੇਗਾ ਅਤੇ del c.x deleter ਨੂੰ ਕਾਲ ਕਰੇਗਾ।

ਜੇ ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ, ਤਾਂ doc property attribute ਦੀ docstring ਹੋਵੇਗੀ। ਨਹੀਂ ਤਾਂ property, fget ਦੀ docstring (ਜੇ ਉਹ ਮੌਜੂਦ ਹੋਵੇ) ਕਾਪੀ ਕਰੇਗੀ। ਇਸ ਨਾਲ @property ਨੂੰ decorator ਵਜੋਂ ਵਰਤ ਕੇ ਸਿਰਫ਼-ਪੜ੍ਹਨਯੋਗ properties ਆਸਾਨੀ ਨਾਲ ਬਣਾਉਣਾ ਸੰਭਵ ਹੁੰਦਾ ਹੈ:

class Parrot:
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

@property decorator voltage() method ਨੂੰ ਉਸੇ ਨਾਮ ਵਾਲੇ read-only attribute ਲਈ "getter" ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ ਅਤੇ voltage ਦੀ docstring ਨੂੰ "Get the current voltage." ਵਜੋਂ ਸੈੱਟ ਕਰਦਾ ਹੈ।

@getter

@setter

@deleter

ਇੱਕ property object ਵਿੱਚ getter, setter ਅਤੇ deleter methods ਹੁੰਦੀਆਂ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ decorators ਵਜੋਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ property ਦੀ ਇੱਕ ਕਾਪੀ ਬਣਾਉਂਦੀਆਂ ਹਨ ਜਿਸ ਵਿੱਚ ਸੰਬੰਧਿਤ accessor function ਨੂੰ decorated function ਨਾਲ ਸੈੱਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਸ ਨੂੰ ਇੱਕ ਉਦਾਹਰਨ ਨਾਲ ਸਭ ਤੋਂ ਵਧੀਆ ਢੰਗ ਨਾਲ ਸਮਝਿਆ ਜਾ ਸਕਦਾ ਹੈ:

class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

ਇਹ ਕੋਡ ਪਹਿਲੀ ਉਦਾਹਰਨ ਦੇ ਬਿਲਕੁਲ ਬਰਾਬਰ ਹੈ। ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਵਾਧੂ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਮੂਲ property ਵਾਲਾ ਹੀ ਨਾਮ ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ (ਇਸ ਮਾਮਲੇ ਵਿੱਚ x)।

ਵਾਪਸ ਕੀਤੇ ਗਏ property ਆਬਜੈਕਟ ਵਿੱਚ constructor ਆਰਗੂਮੈਂਟਾਂ ਦੇ ਅਨੁਸਾਰ fget, fset ਅਤੇ fdel ਗੁਣ ਵੀ ਹੁੰਦੇ ਹਨ।

Changed in version 3.5: ਹੁਣ property ਆਬਜੈਕਟਾਂ ਦੇ docstring ਲਿਖਣਯੋਗ ਹਨ।

__name__

ਇਹ ਗੁਣ property ਦਾ ਨਾਮ ਸੰਭਾਲਦਾ ਹੈ। property ਦਾ ਨਾਮ runtime ਦੌਰਾਨ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ।

Added in version 3.13.

class range(stop, /)

class range(start, stop, step=1, /)

ਫੰਕਸ਼ਨ ਹੋਣ ਦੀ ਬਜਾਇ, range ਅਸਲ ਵਿੱਚ ਇੱਕ immutable sequence type ਹੈ, ਜਿਵੇਂ ਕਿ Ranges ਅਤੇ Sequence Types --- list, tuple, range ਵਿੱਚ ਦਰਸਾਇਆ ਗਿਆ ਹੈ।

repr(object, /)

ਕਿਸੇ ਓਬਜੈਕਟ ਦੀ ਪ੍ਰਿੰਟ ਕਰਨ ਯੋਗ ਪ੍ਰਤੀਨਿਧਤਾ ਵਾਲੀ ਸਟਰਿੰਗ ਵਾਪਸ ਕਰੋ। ਕਈ ਕਿਸਮਾਂ ਲਈ, ਇਹ ਫੰਕਸ਼ਨ ਇੱਕ ਐਸੀ ਸਟਰਿੰਗ ਵਾਪਸ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ ਜੋ eval() ਨੂੰ ਪਾਸ ਕਰਨ 'ਤੇ ਉਹੀ ਮੁੱਲ ਵਾਲਾ ਓਬਜੈਕਟ ਦੇਵੇ; ਨਹੀਂ ਤਾਂ, ਪ੍ਰਤੀਨਿਧਤਾ ਕੋਣ-ਬ੍ਰੈਕਟਾਂ ਵਿੱਚ ਬੰਦ ਇੱਕ ਸਟਰਿੰਗ ਹੁੰਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਓਬਜੈਕਟ ਦੀ ਕਿਸਮ ਦਾ ਨਾਮ ਅਤੇ ਅਕਸਰ ਓਬਜੈਕਟ ਦਾ ਨਾਮ ਅਤੇ ਪਤਾ ਵੀ ਸ਼ਾਮਿਲ ਹੁੰਦਾ ਹੈ। ਇੱਕ ਕਲਾਸ ਆਪਣੇ ਇੰਸਟੈਂਸਾਂ ਲਈ ਇਹ ਫੰਕਸ਼ਨ ਕੀ ਵਾਪਸ ਕਰੇਗਾ, ਇਹ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਇੱਕ __repr__() ਵਿਧੀ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਸਕਦੀ ਹੈ। ਜੇ sys.displayhook() ਉਪਲਬਧ ਨਾ ਹੋਵੇ, ਤਾਂ ਇਹ ਫੰਕਸ਼ਨ RuntimeError ਉਠਾਏਗਾ।

ਇਸ ਕਲਾਸ ਦੀ ਇੱਕ ਕਸਟਮ ਨੁਮਾਇੰਦਗੀ ਹੈ ਜਿਸਦਾ ਮੁਲਾਂਕਣ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:

class Person:
   def __init__(self, name, age):
      self.name = name
      self.age = age

   def __repr__(self):
      return f"Person({self.name!r}, {self.age!r})"

reversed(object, /)

ਇੱਕ ਉਲਟਾ iterator ਵਾਪਸ ਕਰਦਾ ਹੈ। Argument ਇੱਕ ਅਜਿਹਾ object ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜਿਸ ਵਿੱਚ __reversed__() method ਹੋਵੇ ਜਾਂ ਜੋ sequence protocol ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੋਵੇ (__len__() method ਅਤੇ __getitem__() method ਜਿਸਦੇ integer arguments 0 ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ)।

round(number, ndigits=None)

ਦਸ਼ਮਲਵ ਬਿੰਦੂ ਤੋਂ ਬਾਅਦ ndigits ਸ਼ੁੱਧਤਾ ਤੱਕ ਗੋਲ ਕੀਤਾ ਹੋਇਆ number ਵਾਪਸ ਕਰੋ। ਜੇ ndigits ਛੱਡ ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ ਜਾਂ None ਹੋਵੇ, ਤਾਂ ਇਨਪੁੱਟ ਦੇ ਸਭ ਤੋਂ ਨੇੜਲੇ ਪੂਰਨ ਅੰਕ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ।

round() ਨੂੰ ਸਮਰਥਨ ਦੇਣ ਵਾਲੀਆਂ built-in ਕਿਸਮਾਂ ਲਈ, ਮੁੱਲਾਂ ਨੂੰ 10 ਦੀ ਘਾਤ minus ndigits ਦੇ ਸਭ ਤੋਂ ਨੇੜਲੇ multiple ਤੱਕ ਗੋਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਜੇ ਦੋ multiples ਇਕੋ ਜਿਹੇ ਨੇੜੇ ਹੋਣ, ਤਾਂ even ਚੋਣ ਵੱਲ ਗੋਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ (ਉਦਾਹਰਨ ਲਈ round(0.5) ਅਤੇ round(-0.5) ਦੋਵੇਂ 0 ਹਨ, ਜਦਕਿ round(1.5) 2 ਹੈ)। ndigits ਲਈ ਕੋਈ ਵੀ integer ਮੁੱਲ (positive, zero ਜਾਂ negative) ਵੈਧ ਹੈ। ਜੇ ndigits ਛੱਡ ਦਿੱਤਾ ਜਾਵੇ ਜਾਂ None ਹੋਵੇ, ਤਾਂ ਨਤੀਜਾ integer ਹੁੰਦਾ ਹੈ; ਨਹੀਂ ਤਾਂ ਨਤੀਜੇ ਦੀ ਕਿਸਮ number ਵਰਗੀ ਹੀ ਹੁੰਦੀ ਹੈ।

ਸਧਾਰਣ Python ਆਬਜੈਕਟ number ਲਈ, round ਕਾਰਵਾਈ ਨੂੰ number.__round__ ਨੂੰ ਸੌਂਪਦਾ ਹੈ।

Note

float ਮੁੱਲਾਂ ਲਈ round() ਦਾ ਵਿਵਹਾਰ ਹੈਰਾਨੀਜਨਕ ਹੋ ਸਕਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, round(2.675, 2) ਉਮੀਦ ਕੀਤੇ 2.68 ਦੀ ਬਜਾਏ 2.67 ਦਿੰਦਾ ਹੈ। ਇਹ ਕੋਈ bug ਨਹੀਂ ਹੈ; ਇਸਦਾ ਕਾਰਨ ਇਹ ਹੈ ਕਿ ਬਹੁਤ ਸਾਰੇ decimal fractions ਨੂੰ float ਵਜੋਂ ਬਿਲਕੁਲ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਦਰਸਾਇਆ ਨਹੀਂ ਜਾ ਸਕਦਾ। ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਲਈ ਫਲੋਟਿੰਗ-ਪੌਇੰਟ ਅੰਕਗਣਿਤ: ਸਮੱਸਿਆਵਾਂ ਅਤੇ ਸੀਮਾਵਾਂ ਵੇਖੋ।

class set(iterable=(), /)

ਇੱਕ ਨਵਾਂ set object ਵਾਪਸ ਕਰੋ, ਚਾਹੋ ਤਾਂ iterable ਤੋਂ ਲਏ ਗਏ elements ਨਾਲ। set ਇੱਕ built-in class ਹੈ। ਇਸ class ਬਾਰੇ ਦਸਤਾਵੇਜ਼ੀਕਰਨ ਲਈ Set Types --- set, frozenset ਵੀ ਵੇਖੋ।

ਹੋਰ containers ਲਈ built-in frozenset, list, tuple, dict ਕਲਾਸਾਂ ਅਤੇ collections ਮੋਡੀਊਲ ਵੇਖੋ।

setattr(object, name, value, /)

ਇਹ getattr() ਦਾ ਸਮਕੱਖ ਹੈ। Arguments ਇੱਕ object, ਇੱਕ string ਅਤੇ ਕੋਈ ਵੀ ਮੁੱਲ ਹੁੰਦੇ ਹਨ। String ਕਿਸੇ ਮੌਜੂਦਾ attribute ਜਾਂ ਨਵੇਂ attribute ਦਾ ਨਾਮ ਹੋ ਸਕਦੀ ਹੈ। ਜੇ object ਇਜਾਜ਼ਤ ਦੇਵੇ, ਤਾਂ ਇਹ ਫੰਕਸ਼ਨ ਉਸ attribute ਨੂੰ ਦਿੱਤਾ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, setattr(x, 'foobar', 123) , x.foobar = 123 ਦੇ ਬਰਾਬਰ ਹੈ।

name ਦਾ Names (identifiers and keywords) ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ Python identifier ਹੋਣਾ ਲਾਜ਼ਮੀ ਨਹੀਂ ਹੈ, ਜਦ ਤੱਕ object ਖੁਦ ਇਸਨੂੰ ਲਾਗੂ ਨਾ ਕਰੇ, ਜਿਵੇਂ ਕਿ custom __getattribute__() ਜਾਂ __slots__ ਰਾਹੀਂ। ਜਿਸ attribute ਦਾ ਨਾਮ identifier ਨਹੀਂ ਹੈ, ਉਸਨੂੰ dot notation ਨਾਲ ਨਹੀਂ ਪਹੁੰਚਿਆ ਜਾ ਸਕਦਾ, ਪਰ getattr() ਆਦਿ ਰਾਹੀਂ ਪਹੁੰਚਿਆ ਜਾ ਸਕਦਾ ਹੈ।

Note

ਕਿਉਂਕਿ private name mangling compilation ਸਮੇਂ ਹੁੰਦੀ ਹੈ, ਇਸ ਲਈ ਕਿਸੇ private attribute (ਜਿਸਦੇ ਨਾਮ ਦੇ ਅੱਗੇ ਦੋ underscores ਹੁੰਦੇ ਹਨ) ਨੂੰ setattr() ਨਾਲ ਸੈੱਟ ਕਰਨ ਲਈ ਉਸਦਾ ਨਾਮ ਹੱਥੋਂ mangle ਕਰਨਾ ਪੈਂਦਾ ਹੈ।

class sentinel(name, /, *, repr=None)

ਇੱਕ ਨਵਾਂ ਵਿਲੱਖਣ sentinel ਆਬਜੈਕਟ ਵਾਪਸ ਕਰੋ। name ਇੱਕ str ਹੋਣਾ ਲਾਜ਼ਮੀ ਹੈ ਅਤੇ ਮੂਲ ਰੂਪ ਵਿੱਚ ਵਾਪਸ ਕੀਤੇ ਗਏ ਆਬਜੈਕਟ ਦੀ representation ਵਜੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ:

>>> MISSING = sentinel("MISSING")
>>> MISSING
MISSING

ਵਿਕਲਪਿਕ repr ਆਰਗੂਮੈਂਟ ਨੂੰ ਵੱਖਰੀ representation ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ:

>>> MISSING = sentinel("MISSING", repr="<MISSING>")
>>> MISSING
<MISSING>

Sentinel ਆਬਜੈਕਟ truthy ਹੁੰਦੇ ਹਨ ਅਤੇ ਕੇਵਲ ਆਪਣੇ ਆਪ ਨਾਲ ਹੀ ਬਰਾਬਰ ਮੰਨੇ ਜਾਂਦੇ ਹਨ। ਇਨ੍ਹਾਂ ਦੀ ਤੁਲਨਾ is operator ਨਾਲ ਕਰਨ ਲਈ ਬਣਾਈ ਗਈ ਹੈ।

sentinel subclassing ਦਾ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦਾ।

Sentinel ਆਬਜੈਕਟ ਦੀਆਂ shallow ਅਤੇ deep copies ਉਸੇ ਆਬਜੈਕਟ ਨੂੰ ਵਾਪਸ ਕਰਦੀਆਂ ਹਨ।

ਰਵਾਇਤੀ ਤੌਰ 'ਤੇ sentinel ਆਬਜੈਕਟਾਂ ਨੂੰ ਉਸੇ ਨਾਮ ਵਾਲੇ ਵੇਰੀਏਬਲ ਨਾਲ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਤਰੀਕੇ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ sentinel type hints ਵਿੱਚ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ:

MISSING = sentinel("MISSING")

def next_value(default: int | MISSING = MISSING):
    ...

Sentinel ਆਬਜੈਕਟ type expressions ਵਿੱਚ ਵਰਤੋਂ ਲਈ | operator ਦਾ ਸਮਰਥਨ ਕਰਦੇ ਹਨ।

Pickling ਉਹਨਾਂ sentinel objects ਲਈ ਸਮਰਥਿਤ ਹੈ ਜੋ ਕਿਸੇ module ਦੇ global scope ਵਿੱਚ sentinel ਦੇ ਨਾਮ ਨਾਲ ਮਿਲਦੇ ਨਾਮ ਹੇਠ ਰੱਖੇ ਗਏ ਹੋਣ, ਅਤੇ ਉਹਨਾਂ sentinels ਲਈ ਵੀ ਜੋ class scope ਵਿੱਚ sentinel ਦੇ qualified name ਨਾਲ ਮਿਲਦੇ ਨਾਮ ਹੇਠ ਰੱਖੇ ਗਏ ਹੋਣ। ਹੋਰ sentinels, ਜਿਵੇਂ ਕਿ function scope ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ sentinels, picklable ਨਹੀਂ ਹੁੰਦੇ। Pickling ਤੋਂ ਬਾਅਦ ਵੀ sentinel ਦੀ ਪਹਿਚਾਣ ਸੁਰੱਖਿਅਤ ਰਹਿੰਦੀ ਹੈ:

import pickle

PICKLABLE = sentinel("PICKLABLE")

assert pickle.loads(pickle.dumps(PICKLABLE)) is PICKLABLE

class Cls:
    PICKLABLE = sentinel("Cls.PICKLABLE")

assert pickle.loads(pickle.dumps(Cls.PICKLABLE)) is Cls.PICKLABLE

Sentinel ਆਬਜੈਕਟਾਂ ਦੇ ਹੇਠ ਲਿਖੇ ਗੁਣ ਹੁੰਦੇ ਹਨ:

__name__

sentinel ਦਾ ਨਾਮ।

__module__

ਉਸ ਮੋਡੀਊਲ ਦਾ ਨਾਮ ਜਿੱਥੇ sentinel ਬਣਾਇਆ ਗਿਆ ਸੀ। ਇਹ ਗੁਣ ਲਿਖਣਯੋਗ ਹੈ।

Added in version 3.15.

class slice(stop, /)

class slice(start, stop, step=None, /)

range(start, stop, step) ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਇੰਡੈਕਸਾਂ ਦੇ ਸਮੂਹ ਨੂੰ ਦਰਸਾਉਂਦਾ ਇੱਕ slice ਆਬਜੈਕਟ ਵਾਪਸ ਕਰੋ। start ਅਤੇ step ਆਰਗੂਮੈਂਟਾਂ ਦਾ ਮੂਲ ਮੁੱਲ None ਹੈ।

ਜਦੋਂ slicing syntax ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਤਾਂ slice ਆਬਜੈਕਟ ਵੀ ਬਣਾਏ ਜਾਂਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ: a[start:stop:step] ਜਾਂ a[start:stop, i]।

ਵਿਕਲਪਿਕ ਸੰਸਕਰਣ ਲਈ ਜੋ ਇੱਕ iterator ਵਾਪਸ ਕਰਦਾ ਹੈ, itertools.islice() ਵੇਖੋ।

start

stop

step

ਇਹ read-only attributes ਆਰਗੂਮੈਂਟਾਂ ਦੇ ਮੁੱਲਾਂ (ਜਾਂ ਉਨ੍ਹਾਂ ਦੇ ਮੂਲ ਮੁੱਲਾਂ) ਤੇ ਸੈੱਟ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਇਨ੍ਹਾਂ ਦੀ ਕੋਈ ਹੋਰ ਸਪਸ਼ਟ ਕਾਰਗੁਜ਼ਾਰੀ ਨਹੀਂ ਹੈ; ਹਾਲਾਂਕਿ, NumPy ਅਤੇ ਹੋਰ third-party packages ਇਨ੍ਹਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ।

Changed in version 3.12: Slice ਆਬਜੈਕਟ ਹੁਣ hashable ਹਨ (ਜੇ start, stop ਅਤੇ step hashable ਹੋਣ)।

sorted(iterable, /, *, key=None, reverse=False)

iterable ਦੇ ਤੱਤਾਂ ਤੋਂ ਇੱਕ ਨਵੀਂ ਕ੍ਰਮਬੱਧ ਸੂਚੀ ਵਾਪਸ ਕਰੋ।

ਇਸ ਵਿੱਚ ਦੋ ਵਿਕਲਪਿਕ ਆਰਗੂਮੈਂਟ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ keyword arguments ਵਜੋਂ ਦੇਣਾ ਲਾਜ਼ਮੀ ਹੈ।

key ਇੱਕ ਐਸਾ ਫੰਕਸ਼ਨ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਜੋ ਇੱਕ ਆਰਗੂਮੈਂਟ ਲੈਂਦਾ ਹੈ ਅਤੇ iterable ਦੇ ਹਰ ਤੱਤ ਤੋਂ ਤੁਲਨਾ ਲਈ ਕੁੰਜੀ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ (ਉਦਾਹਰਨ ਲਈ key=str.lower)। ਮੂਲ ਮੁੱਲ None ਹੈ (ਤੱਤਾਂ ਦੀ ਸਿੱਧੀ ਤੁਲਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ)।

reverse ਇੱਕ boolean ਮੁੱਲ ਹੈ। ਜੇ ਇਸ ਨੂੰ True ਕੀਤਾ ਜਾਵੇ ਤਾਂ ਸੂਚੀ ਦੇ ਤੱਤਾਂ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਕ੍ਰਮਬੱਧ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਿਵੇਂ ਹਰ ਤੁਲਨਾ ਉਲਟੀ ਹੋਵੇ।

ਪੁਰਾਣੀ ਸ਼ੈਲੀ ਦੇ cmp ਫੰਕਸ਼ਨ ਨੂੰ key ਫੰਕਸ਼ਨ ਵਿੱਚ ਬਦਲਣ ਲਈ functools.cmp_to_key() ਵਰਤੋ।

Built-in sorted() ਫੰਕਸ਼ਨ ਦੇ stable ਹੋਣ ਦੀ ਗਾਰੰਟੀ ਹੈ। ਕੋਈ sort ਉਸ ਵੇਲੇ stable ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਉਹ ਇੱਕੋ ਜਿਹੀ ਤੁਲਨਾ ਵਾਲੇ ਤੱਤਾਂ ਦੀ ਆਪਸੀ ਕ੍ਰਮਵਾਰਤਾ ਨੂੰ ਨਹੀਂ ਬਦਲਦਾ। ਇਹ ਕਈ ਪੜਾਵਾਂ ਵਿੱਚ sorting ਕਰਨ ਲਈ ਲਾਭਦਾਇਕ ਹੈ (ਉਦਾਹਰਨ ਲਈ ਪਹਿਲਾਂ department ਅਨੁਸਾਰ ਅਤੇ ਫਿਰ salary grade ਅਨੁਸਾਰ sort ਕਰਨਾ)।

Sort algorithm ਤੱਤਾਂ ਵਿਚਕਾਰ ਕੇਵਲ < ਤੁਲਨਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਭਾਵੇਂ sorting ਲਈ __lt__() method ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਕਾਫ਼ੀ ਹੈ, PEP 8 ਸਿਫ਼ਾਰਸ਼ ਕਰਦਾ ਹੈ ਕਿ ਸਾਰੀਆਂ ਛੇ rich comparisons ਲਾਗੂ ਕੀਤੀਆਂ ਜਾਣ। ਇਸ ਨਾਲ ਉਹਨਾਂ bugs ਤੋਂ ਬਚਣ ਵਿੱਚ ਮਦਦ ਮਿਲਦੀ ਹੈ ਜੋ ਇੱਕੋ ਡਾਟਾ ਨੂੰ max() ਵਰਗੇ ਹੋਰ ordering tools ਨਾਲ ਵਰਤਣ ਸਮੇਂ ਪੈਦਾ ਹੋ ਸਕਦੇ ਹਨ, ਕਿਉਂਕਿ ਉਹ ਵੱਖਰੇ underlying methods 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ। ਸਾਰੀਆਂ ਛੇ ਤੁਲਨਾਵਾਂ ਲਾਗੂ ਕਰਨ ਨਾਲ mixed type comparisons ਵਿੱਚ ਹੋਣ ਵਾਲੀ ਉਲਝਣ ਤੋਂ ਵੀ ਬਚਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਜਿੱਥੇ reflected __gt__() method ਨੂੰ ਕਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

sorting ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਅਤੇ ਸੰਖੇਪ tutorial ਲਈ ਸੋਰਟਿੰਗ ਤਕਨੀਕਾਂ ਵੇਖੋ।

@staticmethod

ਇੱਕ method ਨੂੰ static method ਵਿੱਚ ਬਦਲੋ।

Static method ਨੂੰ ਕੋਈ implicit ਪਹਿਲਾ ਆਰਗੂਮੈਂਟ ਨਹੀਂ ਮਿਲਦਾ। Static method ਘੋਸ਼ਿਤ ਕਰਨ ਲਈ ਇਹ ਰੂਪ ਵਰਤੋ:

class C:
    @staticmethod
    def f(arg1, arg2, argN): ...

@staticmethod ਰੂਪ ਇੱਕ function decorator ਹੈ — ਵੇਰਵਿਆਂ ਲਈ Function definitions ਵੇਖੋ।

ਇੱਕ static method ਨੂੰ class ਉੱਤੇ (ਜਿਵੇਂ C.f()) ਜਾਂ instance ਉੱਤੇ (ਜਿਵੇਂ C().f()) ਦੋਵੇਂ ਤਰੀਕਿਆਂ ਨਾਲ ਕਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, static method descriptor ਆਪ ਵੀ callable ਹੁੰਦਾ ਹੈ, ਇਸ ਲਈ ਇਸਨੂੰ class definition ਦੇ ਅੰਦਰ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ (ਜਿਵੇਂ f())।

Python ਵਿੱਚ static methods, Java ਜਾਂ C++ ਵਿੱਚ ਮਿਲਣ ਵਾਲੇ static methods ਦੇ ਸਮਾਨ ਹਨ। ਇਸਦੇ ਨਾਲ @classmethod ਵੀ ਵੇਖੋ, ਜੋ alternate class constructors ਬਣਾਉਣ ਲਈ ਲਾਭਦਾਇਕ ਇੱਕ variant ਹੈ।

ਹੋਰ decorators ਵਾਂਗ, staticmethod ਨੂੰ ਇੱਕ ਆਮ function ਵਜੋਂ ਕਾਲ ਕਰਨਾ ਅਤੇ ਉਸਦੇ ਨਤੀਜੇ ਨਾਲ ਕੰਮ ਕਰਨਾ ਵੀ ਸੰਭਵ ਹੈ। ਇਹ ਕੁਝ ਹਾਲਤਾਂ ਵਿੱਚ ਲੋੜੀਂਦਾ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਤੁਹਾਨੂੰ class body ਦੇ ਅੰਦਰੋਂ ਕਿਸੇ function ਦਾ reference ਚਾਹੀਦਾ ਹੋਵੇ ਅਤੇ ਤੁਸੀਂ ਉਸਦੀ instance method ਵਿੱਚ ਹੋਣ ਵਾਲੀ automatic transformation ਤੋਂ ਬਚਣਾ ਚਾਹੁੰਦੇ ਹੋ। ਅਜਿਹੀਆਂ ਹਾਲਤਾਂ ਵਿੱਚ ਇਹ idiom ਵਰਤੋ:

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

Static methods ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ The standard type hierarchy ਵੇਖੋ।

Changed in version 3.10: Static methods ਹੁਣ method attributes (__module__, __name__, __qualname__, __doc__ ਅਤੇ __annotations__) ਨੂੰ inherit ਕਰਦੇ ਹਨ, ਉਨ੍ਹਾਂ ਕੋਲ ਨਵਾਂ __wrapped__ attribute ਵੀ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਹੁਣ ਉਨ੍ਹਾਂ ਨੂੰ ਆਮ functions ਵਾਂਗ ਕਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

class str(*, encoding='utf-8', errors='strict')

class str(object)

class str(object, encoding, errors='strict')

class str(object, *, errors)

object ਦਾ str ਰੂਪ ਵਾਪਸ ਕਰੋ। ਵੇਰਵਿਆਂ ਲਈ str() ਵੇਖੋ।

str built-in string class ਹੈ। Strings ਬਾਰੇ ਆਮ ਜਾਣਕਾਰੀ ਲਈ Text Sequence Type --- str ਵੇਖੋ।

sum(iterable, /, start=0)

start ਅਤੇ iterable ਦੇ ਤੱਤਾਂ ਨੂੰ ਖੱਬੇ ਤੋਂ ਸੱਜੇ ਜੋੜ ਕੇ ਕੁੱਲ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ। iterable ਦੇ ਤੱਤ ਆਮ ਤੌਰ 'ਤੇ ਸੰਖਿਆਵਾਂ ਹੁੰਦੇ ਹਨ ਅਤੇ start ਮੁੱਲ ਨੂੰ string ਹੋਣ ਦੀ ਇਜਾਜ਼ਤ ਨਹੀਂ ਹੈ।

ਕੁਝ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ sum() ਦੇ ਚੰਗੇ ਵਿਕਲਪ ਮੌਜੂਦ ਹਨ। Strings ਦੀ ਲੜੀ ਨੂੰ ਜੋੜਨ ਦਾ ਤਰਜੀਹੀ ਅਤੇ ਤੇਜ਼ ਤਰੀਕਾ ''.join(sequence) ਨੂੰ ਕਾਲ ਕਰਨਾ ਹੈ। ਵੱਧ ਸ਼ੁੱਧਤਾ ਨਾਲ floating-point ਮੁੱਲ ਜੋੜਣ ਲਈ math.fsum() ਵੇਖੋ। ਕਈ iterables ਨੂੰ ਜੋੜਣ ਲਈ itertools.chain() ਵਰਤਣ ਬਾਰੇ ਸੋਚੋ।

Changed in version 3.8: start ਪੈਰਾਮੀਟਰ ਨੂੰ keyword argument ਵਜੋਂ ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ।

Changed in version 3.12: Float ਮੁੱਲਾਂ ਦੇ ਜੋੜ ਲਈ ਹੁਣ ਇੱਕ ਐਲਗੋਰਿਦਮ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜੋ ਜ਼ਿਆਦਾਤਰ builds ਵਿੱਚ ਵੱਧ ਸ਼ੁੱਧਤਾ ਅਤੇ ਬਿਹਤਰ commutativity ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

Changed in version 3.14: Complex ਸੰਖਿਆਵਾਂ ਦੇ ਜੋੜ ਲਈ ਵਿਸ਼ੇਸ਼ ਸਮਰਥਨ ਜੋੜਿਆ ਗਿਆ ਹੈ, ਜੋ floats ਦੇ ਜੋੜ ਵਾਲੇ ਹੀ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।

class super

class super(type, object_or_type=None, /)

ਇੱਕ proxy object ਵਾਪਸ ਕਰੋ ਜੋ method calls ਨੂੰ type ਦੀ parent ਜਾਂ sibling class ਵੱਲ delegate ਕਰਦਾ ਹੈ। ਇਹ ਉਹਨਾਂ inherited methods ਤੱਕ ਪਹੁੰਚ ਲਈ ਲਾਭਦਾਇਕ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਕਿਸੇ class ਵਿੱਚ override ਕੀਤਾ ਗਿਆ ਹੋਵੇ।

object_or_type ਉਸ method resolution order ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਖੋਜ ਕੀਤੀ ਜਾਣੀ ਹੈ। ਖੋਜ type ਤੋਂ ਤੁਰੰਤ ਬਾਅਦ ਆਉਣ ਵਾਲੀ class ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ।

ਉਦਾਹਰਨ ਲਈ, ਜੇ object_or_type ਦਾ __mro__ D -> B -> C -> A -> object ਹੋਵੇ ਅਤੇ type ਦਾ ਮੁੱਲ B ਹੋਵੇ, ਤਾਂ super() C -> A -> object ਵਿੱਚ ਖੋਜ ਕਰਦਾ ਹੈ।

object_or_type ਨਾਲ ਸੰਬੰਧਿਤ class ਦਾ __mro__ attribute ਉਸ method resolution search order ਦੀ ਸੂਚੀ ਦਿੰਦਾ ਹੈ ਜੋ getattr() ਅਤੇ super() ਦੋਵਾਂ ਦੁਆਰਾ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ attribute dynamic ਹੈ ਅਤੇ inheritance hierarchy ਵਿੱਚ ਤਬਦੀਲੀ ਆਉਣ 'ਤੇ ਬਦਲ ਸਕਦਾ ਹੈ।

ਜੇ ਦੂਜਾ argument ਛੱਡ ਦਿੱਤਾ ਜਾਵੇ, ਤਾਂ ਵਾਪਸ ਕੀਤਾ ਗਿਆ super object unbound ਹੁੰਦਾ ਹੈ। ਜੇ ਦੂਜਾ argument ਇੱਕ object ਹੋਵੇ, ਤਾਂ isinstance(obj, type) ਸੱਚ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਜੇ ਦੂਜਾ argument ਇੱਕ type ਹੋਵੇ, ਤਾਂ issubclass(type2, type) ਸੱਚ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ (ਇਹ classmethods ਲਈ ਲਾਭਦਾਇਕ ਹੈ)।

ਜਦੋਂ ਇਸਨੂੰ ਕਿਸੇ class ਦੀ ਆਮ method ਦੇ ਅੰਦਰ ਸਿੱਧੇ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਦੋਵੇਂ arguments ਛੱਡੇ ਜਾ ਸਕਦੇ ਹਨ ("zero-argument super()")। ਇਸ ਹਾਲਤ ਵਿੱਚ type enclosing class ਹੋਵੇਗੀ ਅਤੇ obj ਤੁਰੰਤ enclosing function ਦਾ ਪਹਿਲਾ argument ਹੋਵੇਗਾ (ਆਮ ਤੌਰ 'ਤੇ self)। (ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ zero-argument super() nested functions ਦੇ ਅੰਦਰ, ਜਿਵੇਂ generator expressions, ਵਿੱਚ ਉਮੀਦ ਅਨੁਸਾਰ ਕੰਮ ਨਹੀਂ ਕਰੇਗਾ ਕਿਉਂਕਿ ਉਹ ਅੰਦਰੂਨੀ ਤੌਰ 'ਤੇ nested functions ਬਣਾਉਂਦੇ ਹਨ।)

super ਦੇ ਦੋ ਆਮ ਵਰਤੋਂ-ਮਾਮਲੇ ਹਨ। Single inheritance ਵਾਲੀ class hierarchy ਵਿੱਚ super ਦੀ ਵਰਤੋਂ parent classes ਨੂੰ ਬਿਨਾਂ ਸਿੱਧਾ ਨਾਮ ਲਏ ਸੰਬੋਧਨ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਜਿਸ ਨਾਲ ਕੋਡ ਦੀ ਸੰਭਾਲ ਕਰਨਾ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ। ਇਹ ਵਰਤੋਂ ਹੋਰ programming languages ਵਿੱਚ super ਦੀ ਵਰਤੋਂ ਨਾਲ ਕਾਫ਼ੀ ਮਿਲਦੀ ਹੈ।

ਦੂਜਾ ਵਰਤੋਂ-ਮਾਮਲਾ dynamic execution environment ਵਿੱਚ cooperative multiple inheritance ਦਾ ਸਮਰਥਨ ਕਰਨਾ ਹੈ। ਇਹ ਵਰਤੋਂ Python ਲਈ ਵਿਲੱਖਣ ਹੈ ਅਤੇ statically compiled languages ਜਾਂ ਉਹਨਾਂ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਨਹੀਂ ਮਿਲਦੀ ਜੋ ਕੇਵਲ single inheritance ਦਾ ਸਮਰਥਨ ਕਰਦੀਆਂ ਹਨ। ਇਸ ਨਾਲ "diamond diagrams" ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਸੰਭਵ ਬਣਦਾ ਹੈ, ਜਿੱਥੇ ਕਈ base classes ਇੱਕੋ method ਨੂੰ ਲਾਗੂ ਕਰਦੀਆਂ ਹਨ। ਚੰਗੇ design ਅਨੁਸਾਰ ਅਜਿਹੀਆਂ implementations ਵਿੱਚ ਹਰ ਹਾਲਤ ਵਿੱਚ ਇੱਕੋ calling signature ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ (ਕਿਉਂਕਿ calls ਦਾ ਕ੍ਰਮ runtime ਦੌਰਾਨ ਨਿਰਧਾਰਤ ਹੁੰਦਾ ਹੈ, ਕਿਉਂਕਿ ਉਹ ਕ੍ਰਮ class hierarchy ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਦੇ ਅਨੁਸਾਰ ਬਦਲ ਸਕਦਾ ਹੈ, ਅਤੇ ਕਿਉਂਕਿ ਉਸ ਕ੍ਰਮ ਵਿੱਚ ਅਜਿਹੀਆਂ sibling classes ਵੀ ਸ਼ਾਮਲ ਹੋ ਸਕਦੀਆਂ ਹਨ ਜੋ runtime ਤੋਂ ਪਹਿਲਾਂ ਜਾਣੀਆਂ ਨਾ ਹੋਣ)।

ਦੋਵੇਂ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਇੱਕ ਆਮ superclass ਕਾਲ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ:

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

ਮੈਥਡ lookup ਤੋਂ ਇਲਾਵਾ, super() attribute lookup ਲਈ ਵੀ ਕੰਮ ਕਰਦਾ ਹੈ। ਇਸਦੀ ਇੱਕ ਸੰਭਾਵਿਤ ਵਰਤੋਂ parent ਜਾਂ sibling class ਵਿੱਚ descriptors ਨੂੰ ਕਾਲ ਕਰਨਾ ਹੈ।

ਧਿਆਨ ਦਿਓ ਕਿ super() ਨੂੰ super().__getitem__(name) ਵਰਗੀਆਂ explicit dotted attribute lookups ਲਈ binding process ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਹ ਆਪਣੇ __getattribute__() ਮੈਥਡ ਰਾਹੀਂ classes ਨੂੰ ਇੱਕ ਅਨੁਮਾਨਯੋਗ ਕ੍ਰਮ ਵਿੱਚ ਖੋਜਦਾ ਹੈ ਜੋ cooperative multiple inheritance ਨੂੰ ਸਮਰਥਨ ਦਿੰਦਾ ਹੈ। ਇਸ ਲਈ super()[name] ਵਰਗੀਆਂ implicit lookups ਲਈ super() ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਹੈ।

ਇਹ ਵੀ ਧਿਆਨ ਦਿਓ ਕਿ zero-argument ਰੂਪ ਤੋਂ ਇਲਾਵਾ, super() ਦੀ ਵਰਤੋਂ ਕੇਵਲ ਮੈਥਡਾਂ ਦੇ ਅੰਦਰ ਹੀ ਸੀਮਿਤ ਨਹੀਂ ਹੈ। ਦੋ-ਆਰਗੂਮੈਂਟ ਰੂਪ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਦਰਸਾਉਂਦਾ ਹੈ ਅਤੇ ਉਚਿਤ ਹਵਾਲੇ ਬਣਾਉਂਦਾ ਹੈ। zero-argument ਰੂਪ ਸਿਰਫ਼ class definition ਦੇ ਅੰਦਰ ਹੀ ਕੰਮ ਕਰਦਾ ਹੈ, ਕਿਉਂਕਿ compiler ਲੋੜੀਂਦੇ ਵੇਰਵੇ ਭਰਦਾ ਹੈ ਤਾਂ ਜੋ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੀ ਜਾ ਰਹੀ class ਅਤੇ ਮੌਜੂਦਾ instance ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕੇ।

super() ਦੀ ਵਰਤੋਂ ਕਰਕੇ cooperative classes ਡਿਜ਼ਾਈਨ ਕਰਨ ਲਈ ਵਿਹਾਰਿਕ ਸੁਝਾਵਾਂ ਵਾਸਤੇ guide to using super() ਵੇਖੋ।

Changed in version 3.14: super ਆਬਜੈਕਟ ਹੁਣ pickleable ਅਤੇ copyable ਹਨ।

class tuple(iterable=(), /)

ਫੰਕਸ਼ਨ ਹੋਣ ਦੀ ਬਜਾਏ, tuple ਅਸਲ ਵਿੱਚ ਇੱਕ immutable sequence type ਹੈ, ਜਿਵੇਂ ਕਿ Tuples ਅਤੇ Sequence Types --- list, tuple, range ਵਿੱਚ ਦਸਤਾਵੇਜ਼ਬੱਧ ਕੀਤਾ ਗਿਆ ਹੈ।

class type(object, /)

class type(name, bases, dict, /, **kwargs)

ਇੱਕ ਆਰਗੂਮੈਂਟ ਨਾਲ, object ਦੀ ਕਿਸਮ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਵਾਪਸ ਕੀਤਾ ਗਿਆ ਮੁੱਲ ਇੱਕ type object ਹੁੰਦਾ ਹੈ ਅਤੇ ਆਮ ਤੌਰ 'ਤੇ object.__class__ ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ object ਦੇ ਬਰਾਬਰ ਹੁੰਦਾ ਹੈ।

ਕਿਸੇ object ਦੀ type ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ built-in ਫੰਕਸ਼ਨ isinstance() ਦੀ ਸਿਫ਼ਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿਉਂਕਿ ਇਹ subclasses ਨੂੰ ਵੀ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦਾ ਹੈ।

ਤਿੰਨ arguments ਨਾਲ ਇੱਕ ਨਵਾਂ type object ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਅਸਲ ਵਿੱਚ class statement ਦਾ ਇੱਕ dynamic ਰੂਪ ਹੈ। name string class ਦਾ ਨਾਮ ਹੁੰਦੀ ਹੈ ਅਤੇ __name__ attribute ਬਣ ਜਾਂਦੀ ਹੈ। bases tuple ਵਿੱਚ base classes ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਇਹ __bases__ attribute ਬਣ ਜਾਂਦੀ ਹੈ; ਜੇ ਇਹ ਖਾਲੀ ਹੋਵੇ ਤਾਂ object, ਜੋ ਸਾਰੀਆਂ classes ਦਾ ਆਖਰੀ base ਹੈ, ਜੋੜ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। dict dictionary ਵਿੱਚ class body ਲਈ attributes ਅਤੇ methods ਦੀਆਂ ਪਰਿਭਾਸ਼ਾਵਾਂ ਹੁੰਦੀਆਂ ਹਨ; __dict__ attribute ਬਣਨ ਤੋਂ ਪਹਿਲਾਂ ਇਸਦੀ ਨਕਲ ਕੀਤੀ ਜਾਂ ਇਸਨੂੰ wrap ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਹੇਠਾਂ ਦਿੱਤੇ ਦੋ statements ਇੱਕੋ ਜਿਹੇ type objects ਬਣਾਉਂਦੇ ਹਨ:

>>> class X:
...     a = 1
...
>>> X = type('X', (), dict(a=1))

ਇਹ ਵੀ ਵੇਖੋ:

• Classes ਦੇ attributes ਅਤੇ methods ਬਾਰੇ ਦਸਤਾਵੇਜ਼।

• Type Objects

ਤਿੰਨ-argument ਰੂਪ ਨੂੰ ਦਿੱਤੇ ਗਏ keyword arguments ਨੂੰ ਉਚਿਤ metaclass machinery (ਆਮ ਤੌਰ 'ਤੇ __init_subclass__()) ਤੱਕ ਉਸੇ ਤਰੀਕੇ ਨਾਲ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ ਜਿਵੇਂ class definition ਵਿੱਚ ਦਿੱਤੇ keywords (metaclass ਤੋਂ ਇਲਾਵਾ) ਭੇਜੇ ਜਾਂਦੇ ਹਨ।

class ਬਿਆਨ ਦੇ ਉਲਟ, ਤਿੰਨ-ਅਰਗੂਮੈਂਟ ਰੂਪ ਮੈਟਾਕਲਾਸ __prepare__ ਮੈਥਡ ਨੂੰ ਨਹੀਂ ਬੁਲਾਉਂਦਾ (ਦੇਖੋ Preparing the class namespace)। ਉਚਿਤ ਮੈਟਾਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡਾਇਨਾਮਿਕ ਤੌਰ 'ਤੇ ਕਲਾਸ ਬਣਾਉਣ ਲਈ types.new_class() ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਇਹ ਵੀ ਵੇਖੋ Customizing class creation।

Changed in version 3.6: type ਦੀਆਂ ਉਹ subclasses ਜੋ type.__new__ ਨੂੰ override ਨਹੀਂ ਕਰਦੀਆਂ, ਹੁਣ ਕਿਸੇ object ਦਾ type ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇੱਕ-argument ਰੂਪ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰ ਸਕਦੀਆਂ।

Changed in version 3.15: dict ਹੁਣ frozendict ਵੀ ਹੋ ਸਕਦਾ ਹੈ।

vars()

vars(object, /)

ਕਿਸੇ module, class, instance ਜਾਂ ਕਿਸੇ ਹੋਰ object ਲਈ ਜਿਸ ਵਿੱਚ __dict__ attribute ਹੋਵੇ, ਉਸਦਾ __dict__ attribute ਵਾਪਸ ਕਰਦਾ ਹੈ।

Modules ਅਤੇ instances ਵਰਗੇ objects ਵਿੱਚ ਅਪਡੇਟ ਕੀਤੇ ਜਾ ਸਕਣ ਵਾਲਾ __dict__ attribute ਹੁੰਦਾ ਹੈ; ਪਰ ਹੋਰ objects ਆਪਣੇ __dict__ attribute 'ਤੇ ਲਿਖਣ ਸੰਬੰਧੀ ਪਾਬੰਦੀਆਂ ਰੱਖ ਸਕਦੇ ਹਨ (ਉਦਾਹਰਨ ਲਈ, classes ਸਿੱਧੀਆਂ dictionary updates ਨੂੰ ਰੋਕਣ ਲਈ types.MappingProxyType ਵਰਤਦੀਆਂ ਹਨ)।

ਬਿਨਾਂ ਕਿਸੇ ਆਰਗੂਮੈਂਟ ਦੇ, vars() locals() ਵਾਂਗ ਕੰਮ ਕਰਦਾ ਹੈ।

ਜੇ ਕੋਈ object ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ ਪਰ ਉਸ ਵਿੱਚ __dict__ attribute ਨਾ ਹੋਵੇ (ਉਦਾਹਰਨ ਲਈ, ਜੇ ਉਸਦੀ class __slots__ attribute ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀ ਹੋਵੇ), ਤਾਂ TypeError exception ਉਠਾਈ ਜਾਂਦੀ ਹੈ।

Changed in version 3.13: ਇਸ ਫੰਕਸ਼ਨ ਨੂੰ ਬਿਨਾਂ ਆਰਗੂਮੈਂਟ ਦੇ ਕਾਲ ਕਰਨ ਦਾ ਨਤੀਜਾ ਹੁਣ locals() built-in ਲਈ ਵਰਣਿਤ ਤਰੀਕੇ ਅਨੁਸਾਰ ਅਪਡੇਟ ਕੀਤਾ ਗਿਆ ਹੈ।

zip(*iterables, strict=False)

ਕਈ iterables 'ਤੇ ਸਮਾਂਤਰ ਤੌਰ 'ਤੇ iteration ਕਰਦਾ ਹੈ ਅਤੇ ਹਰ ਇੱਕ ਤੋਂ ਇੱਕ ਤੱਤ ਲੈ ਕੇ tuples ਬਣਾਉਂਦਾ ਹੈ।

ਉਦਾਹਰਨ:

>>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
...     print(item)
...
(1, 'sugar')
(2, 'spice')
(3, 'everything nice')

ਵਧੇਰੇ ਰਸਮੀ ਤੌਰ 'ਤੇ, zip() tuples ਦਾ ਇੱਕ iterator ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜਿੱਥੇ i-ਵੇਂ tuple ਵਿੱਚ ਹਰ argument iterable ਦਾ i-ਵਾਂ ਤੱਤ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ।

zip() ਬਾਰੇ ਸੋਚਣ ਦਾ ਇੱਕ ਹੋਰ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ ਇਹ ਕਤਾਰਾਂ ਨੂੰ ਕਾਲਮਾਂ ਵਿੱਚ ਬਦਲਦਾ ਹੈ, ਅਤੇ ਕਾਲਮਾਂ ਨੂੰ ਕਤਾਰਾਂ ਵਿੱਚ। ਇਹ matrix transpose ਵਰਗਾ ਹੈ।

zip() lazy ਹੈ: ਤੱਤਾਂ ਨੂੰ ਤਦ ਤੱਕ process ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਜਦ ਤੱਕ iterable ਉੱਤੇ iteration ਨਾ ਕੀਤੀ ਜਾਵੇ, ਉਦਾਹਰਨ ਲਈ for loop ਰਾਹੀਂ ਜਾਂ ਇਸਨੂੰ list ਵਿੱਚ wrap ਕਰਕੇ।

ਇੱਕ ਗੱਲ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣ ਯੋਗ ਹੈ ਕਿ zip() ਨੂੰ ਦਿੱਤੇ ਗਏ iterables ਦੀ ਲੰਬਾਈ ਵੱਖ-ਵੱਖ ਹੋ ਸਕਦੀ ਹੈ; ਕਈ ਵਾਰ ਇਹ design ਅਨੁਸਾਰ ਹੁੰਦਾ ਹੈ ਅਤੇ ਕਈ ਵਾਰ ਇਹਨਾਂ iterables ਨੂੰ ਤਿਆਰ ਕਰਨ ਵਾਲੇ code ਵਿੱਚ bug ਕਾਰਨ। Python ਇਸ ਸਮੱਸਿਆ ਨਾਲ ਨਿਪਟਣ ਲਈ ਤਿੰਨ ਵੱਖਰੇ ਤਰੀਕੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ:

• ਡਿਫਾਲਟ ਰੂਪ ਵਿੱਚ, zip() ਉਦੋਂ ਰੁਕ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਸਭ ਤੋਂ ਛੋਟਾ ਇਟਰੇਬਲ exhausted ਹੋ ਜਾਂਦਾ ਹੈ। ਇਹ ਲੰਬੇ ਇਟਰੇਬਲਜ਼ ਵਿੱਚ ਬਾਕੀ ਰਹਿ ਗਈਆਂ ਆਈਟਮਾਂ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰ ਦੇਵੇਗਾ ਅਤੇ ਨਤੀਜੇ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟੇ ਇਟਰੇਬਲ ਦੀ ਲੰਬਾਈ ਤੱਕ ਸੀਮਿਤ ਕਰ ਦੇਵੇਗਾ:

  >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
  [(0, 'fee'), (1, 'fi'), (2, 'fo')]
  

• zip() ਅਕਸਰ ਉਹਨਾਂ ਹਾਲਤਾਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜਿੱਥੇ iterables ਦੀ ਲੰਬਾਈ ਇੱਕੋ ਜਿਹੀ ਮੰਨੀ ਜਾਂਦੀ ਹੈ। ਅਜਿਹੀਆਂ ਹਾਲਤਾਂ ਵਿੱਚ strict=True ਵਿਕਲਪ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਸਿਫ਼ਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸਦਾ output ਆਮ zip() ਵਾਂਗ ਹੀ ਹੁੰਦਾ ਹੈ:

  >>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
  [('a', 1), ('b', 2), ('c', 3)]
  

  ਡਿਫਾਲਟ ਵਿਹਾਰ ਦੇ ਉਲਟ, ਜੇਕਰ ਕੋਈ ਇੱਕ ਇਟਰੇਬਲ ਦੂਜਿਆਂ ਤੋਂ ਪਹਿਲਾਂ exhausted ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ValueError ਉਠਾਉਂਦਾ ਹੈ:

  >>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):
  ...     print(item)
  ...
  (0, 'fee')
  (1, 'fi')
  (2, 'fo')
  Traceback (most recent call last):
    ...
  ValueError: zip() argument 2 is longer than argument 1
  

  strict=True argument ਤੋਂ ਬਿਨਾਂ, ਕੋਈ ਵੀ bug ਜੋ ਵੱਖ-ਵੱਖ ਲੰਬਾਈ ਵਾਲੇ iterables ਪੈਦਾ ਕਰਦਾ ਹੈ, ਚੁੱਪਚਾਪ ਲੁਕਿਆ ਰਹਿ ਸਕਦਾ ਹੈ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮ ਦੇ ਕਿਸੇ ਹੋਰ ਹਿੱਸੇ ਵਿੱਚ ਲੱਭਣ ਲਈ ਮੁਸ਼ਕਲ bug ਵਜੋਂ ਸਾਹਮਣੇ ਆ ਸਕਦਾ ਹੈ।

• ਛੋਟੇ iterables ਨੂੰ ਇੱਕ ਸਥਿਰ ਮੁੱਲ ਨਾਲ ਭਰਿਆ ਜਾ ਸਕਦਾ ਹੈ ਤਾਂ ਜੋ ਸਾਰੇ iterables ਦੀ ਲੰਬਾਈ ਇੱਕੋ ਜਿਹੀ ਹੋ ਜਾਵੇ। ਇਹ ਕੰਮ itertools.zip_longest() ਦੁਆਰਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਖਾਸ ਸਥਿਤੀਆਂ: ਇੱਕ ਹੀ iterable argument ਨਾਲ zip() 1-tuples ਦਾ ਇੱਕ iterator ਵਾਪਸ ਕਰਦਾ ਹੈ। ਬਿਨਾਂ ਕਿਸੇ argument ਦੇ, ਇਹ ਇੱਕ ਖਾਲੀ iterator ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਸੁਝਾਅ ਅਤੇ ਤਰੀਕੇ:

• iterables ਦੇ ਖੱਬੇ ਤੋਂ ਸੱਜੇ ਮੁਲਾਂਕਣ ਕ੍ਰਮ ਦੀ ਗਾਰੰਟੀ ਹੁੰਦੀ ਹੈ। ਇਸ ਨਾਲ zip(*[iter(s)]*n, strict=True) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡਾਟਾ ਲੜੀ ਨੂੰ n-ਲੰਬਾਈ ਵਾਲੇ ਸਮੂਹਾਂ ਵਿੱਚ ਵੰਡਣ ਦਾ ਇੱਕ ਤਰੀਕਾ ਸੰਭਵ ਬਣਦਾ ਹੈ। ਇਹ ਇੱਕੋ iterator ਨੂੰ n ਵਾਰ ਦੁਹਰਾਉਂਦਾ ਹੈ ਤਾਂ ਜੋ ਹਰ ਆਉਟਪੁੱਟ tuple ਵਿੱਚ iterator ਨੂੰ n ਵਾਰ ਕਾਲ ਕਰਨ ਦੇ ਨਤੀਜੇ ਸ਼ਾਮਲ ਹੋਣ। ਇਸ ਦਾ ਪ੍ਰਭਾਵ ਇਨਪੁੱਟ ਨੂੰ n-ਲੰਬਾਈ ਵਾਲੇ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਣਾ ਹੁੰਦਾ ਹੈ।

• zip() ਨੂੰ * operator ਦੇ ਨਾਲ ਵਰਤ ਕੇ ਕਿਸੇ list ਨੂੰ unzip ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:

  >>> x = [1, 2, 3]
  >>> y = [4, 5, 6]
  >>> list(zip(x, y))
  [(1, 4), (2, 5), (3, 6)]
  >>> x2, y2 = zip(*zip(x, y))
  >>> x == list(x2) and y == list(y2)
  True
  

Changed in version 3.10: strict ਆਰਗੂਮੈਂਟ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ।

__import__(name, globals=None, locals=None, fromlist=(), level=0)

Note

ਇਹ ਇੱਕ ਉੱਨਤ ਫੰਕਸ਼ਨ ਹੈ ਜਿਸਦੀ ਰੋਜ਼ਾਨਾ Python ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਲੋੜ ਨਹੀਂ ਪੈਂਦੀ, importlib.import_module() ਦੇ ਉਲਟ।

ਇਹ ਫੰਕਸ਼ਨ import ਸਟੇਟਮੈਂਟ ਦੁਆਰਾ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। (builtins ਮੋਡੀਊਲ ਨੂੰ ਇੰਪੋਰਟ ਕਰਕੇ ਅਤੇ builtins.__import__ ਨੂੰ ਅਸਾਈਨ ਕਰਕੇ ਇਸਨੂੰ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ) ਤਾਂ ਜੋ import ਸਟੇਟਮੈਂਟ ਦੇ ਵਿਹਾਰ ਨੂੰ ਬਦਲਿਆ ਜਾ ਸਕੇ, ਪਰ ਇਸ ਤਰ੍ਹਾਂ ਕਰਨਾ ਸਖ਼ਤ ਤੌਰ 'ਤੇ ਨਿਰੁਤਸਾਹਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਆਮ ਤੌਰ 'ਤੇ import hooks (PEP 302 ਵੇਖੋ) ਵਰਤਣਾ ਹੋਰ ਆਸਾਨ ਹੁੰਦਾ ਹੈ ਅਤੇ ਇਹ ਉਸ ਕੋਡ ਨਾਲ ਸਮੱਸਿਆਵਾਂ ਨਹੀਂ ਪੈਦਾ ਕਰਦਾ ਜੋ ਡਿਫਾਲਟ import ਇੰਪਲੀਮੈਂਟੇਸ਼ਨ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। __import__() ਦੀ ਸਿੱਧੀ ਵਰਤੋਂ ਦੀ ਬਜਾਏ importlib.import_module() ਵਰਤਣ ਦੀ ਸਿਫ਼ਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

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

level ਇਹ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ absolute ਜਾਂ relative imports ਵਰਤਣੇ ਹਨ। 0 (ਡਿਫਾਲਟ) ਦਾ ਅਰਥ ਹੈ ਕਿ ਕੇਵਲ absolute imports ਕੀਤੇ ਜਾਣ। level ਲਈ ਧਨਾਤਮਕ ਮੁੱਲ ਦਰਸਾਉਂਦੇ ਹਨ ਕਿ __import__() ਨੂੰ ਕਾਲ ਕਰਨ ਵਾਲੇ ਮੋਡੀਊਲ ਦੀ ਡਾਇਰੈਕਟਰੀ ਦੇ ਸਬੰਧ ਵਿੱਚ ਕਿੰਨੀਆਂ parent directories ਵਿੱਚ ਖੋਜ ਕੀਤੀ ਜਾਵੇ (PEP 328 ਵੇਖੋ)।

ਜਦੋਂ name ਦਾ ਰੂਪ package.module ਹੋਵੇ, ਤਾਂ ਆਮ ਤੌਰ 'ਤੇ top-level package (ਪਹਿਲੇ dot ਤੱਕ ਦਾ ਨਾਮ) ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, name ਦੁਆਰਾ ਦਰਸਾਇਆ ਮੋਡੀਊਲ ਨਹੀਂ। ਹਾਲਾਂਕਿ, ਜੇ fromlist ਖਾਲੀ ਨਾ ਹੋਵੇ, ਤਾਂ name ਦੁਆਰਾ ਦਰਸਾਇਆ ਮੋਡੀਊਲ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਉਦਾਹਰਨ ਲਈ, import spam ਸਟੇਟਮੈਂਟ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਵਰਗਾ bytecode ਤਿਆਰ ਕਰਦੀ ਹੈ:

spam = __import__('spam', globals(), locals(), [], 0)

import spam.ham ਸਟੇਟਮੈਂਟ ਹੇਠਾਂ ਦਿੱਤੀ ਕਾਲ ਤਿਆਰ ਕਰਦੀ ਹੈ:

spam = __import__('spam.ham', globals(), locals(), [], 0)

ਧਿਆਨ ਦਿਓ ਕਿ ਇੱਥੇ __import__() top-level module ਵਾਪਸ ਕਰਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹੀ ਉਹ ਆਬਜੈਕਟ ਹੈ ਜੋ import ਸਟੇਟਮੈਂਟ ਦੁਆਰਾ ਕਿਸੇ ਨਾਮ ਨਾਲ ਬਾਈਂਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਦੂਜੇ ਪਾਸੇ, from spam.ham import eggs, sausage as saus ਸਟੇਟਮੈਂਟ ਦਾ ਨਤੀਜਾ ਇਹ ਹੁੰਦਾ ਹੈ:

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage

ਇੱਥੇ __import__() ਤੋਂ spam.ham ਮੋਡੀਊਲ ਵਾਪਸ ਮਿਲਦਾ ਹੈ। ਇਸ ਆਬਜੈਕਟ ਤੋਂ ਇੰਪੋਰਟ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਨਾਮ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਉਹਨਾਂ ਦੇ ਸੰਬੰਧਿਤ ਨਾਮਾਂ ਨੂੰ ਅਸਾਈਨ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।

ਜੇ ਤੁਸੀਂ ਸਿਰਫ ਨਾਮ ਰਾਹੀਂ ਕਿਸੇ ਮੋਡੀਊਲ (ਸੰਭਵ ਤੌਰ 'ਤੇ ਕਿਸੇ ਪੈਕੇਜ ਦੇ ਅੰਦਰ) ਨੂੰ ਇੰਪੋਰਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ importlib.import_module() ਵਰਤੋ।

Changed in version 3.3: level ਲਈ ਨਕਾਰਾਤਮਕ ਮੁੱਲ ਹੁਣ ਸਮਰਥਿਤ ਨਹੀਂ ਹਨ (ਅਤੇ ਇਸ ਨਾਲ ਡਿਫਾਲਟ ਮੁੱਲ ਵੀ 0 ਹੋ ਗਿਆ ਹੈ)।

Changed in version 3.9: ਜਦੋਂ command line options -E ਜਾਂ -I ਵਰਤੇ ਜਾਂਦੇ ਹਨ, ਤਾਂ environment variable PYTHONCASEOK ਨੂੰ ਹੁਣ ਅਣਡਿੱਠਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਫੁਟਨੋਟ

[1]

ਧਿਆਨ ਦਿਓ ਕਿ parser ਕੇਵਲ Unix-ਸ਼ੈਲੀ end-of-line convention ਨੂੰ ਹੀ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ। ਜੇ ਤੁਸੀਂ ਫਾਈਲ ਤੋਂ ਕੋਡ ਪੜ੍ਹ ਰਹੇ ਹੋ, ਤਾਂ Windows ਜਾਂ Mac-ਸ਼ੈਲੀ newlines ਨੂੰ ਬਦਲਣ ਲਈ newline conversion mode ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ।