ਸ਼ਬਦਾਵਲੀ

>>>

interactive ਸ਼ੈੱਲ ਦਾ ਮੂਲ Python ਪ੍ਰੌਮਪਟ। ਇਹ ਅਕਸਰ ਉਹਨਾਂ ਕੋਡ ਉਦਾਹਰਣਾਂ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਇੰਟਰਪ੍ਰੀਟਰ ਵਿੱਚ ਇੰਟਰਐਕਟਿਵ ਤਰੀਕੇ ਨਾਲ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।

...

ਇਸਦਾ ਹਵਾਲਾ ਇਹਨਾਂ ਵੱਲ ਹੋ ਸਕਦਾ ਹੈ:

• ਇੰਡੈਂਟ ਕੀਤੇ ਕੋਡ ਬਲਾਕ ਲਈ ਕੋਡ ਦਰਜ ਕਰਨ ਸਮੇਂ, ਜਾਂ ਮਿਲਦੇ ਹੋਏ ਖੱਬੇ ਅਤੇ ਸੱਜੇ ਡਿਲਿਮਿਟਰਾਂ (ਗੋਲ ਬ੍ਰੈਕਟ, ਚੌਰਸ ਬ੍ਰੈਕਟ, ਕਰਲੀ ਬ੍ਰੇਸ ਜਾਂ ਤਿੰਨਹਰੇ ਕੋਟ) ਦੇ ਅੰਦਰ ਹੋਣ ਸਮੇਂ, ਜਾਂ ਕਿਸੇ ਡੈਕੋਰੇਟਰ ਨੂੰ ਦਰਸਾਉਣ ਤੋਂ ਬਾਅਦ interactive ਸ਼ੈੱਲ ਦਾ ਮੂਲ Python ਪ੍ਰੌਮਪਟ।

• Ellipsis ਆਬਜੈਕਟ ਦਾ ਤਿੰਨ ਬਿੰਦੀਆਂ ਵਾਲਾ ਰੂਪ।

ਅਮੂਰਤ ਆਧਾਰ ਕਲਾਸ

ਅਮੂਰਤ ਆਧਾਰ ਕਲਾਸਾਂ duck-typing ਨੂੰ ਪੂਰਾ ਕਰਦੀਆਂ ਹਨ ਅਤੇ ਇੰਟਰਫੇਸ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ ਜਦੋਂ hasattr() ਵਰਗੀਆਂ ਤਕਨੀਕਾਂ ਅਸੁਵਿਧਾਜਨਕ ਜਾਂ ਗਲਤ ਹੋ ਸਕਦੀਆਂ ਹਨ (ਉਦਾਹਰਨ ਲਈ magic methods ਨਾਲ)। ABCs ਵਰਚੁਅਲ ਸਬਕਲਾਸਾਂ ਲਿਆਉਂਦੀਆਂ ਹਨ, ਜੋ ਕਿਸੇ ਕਲਾਸ ਤੋਂ ਵਾਰਸਤ ਨਹੀਂ ਲੈਂਦੀਆਂ ਪਰ ਫਿਰ ਵੀ isinstance() ਅਤੇ issubclass() ਦੁਆਰਾ ਪਛਾਣੀਆਂ ਜਾਂਦੀਆਂ ਹਨ; ਵੇਰਵੇ ਲਈ abc ਮੋਡੀਊਲ ਦੇ ਦਸਤਾਵੇਜ਼ ਵੇਖੋ। Python ਵਿੱਚ ਡਾਟਾ ਸੰਰਚਨਾਵਾਂ (collections.abc), ਸੰਖਿਆਵਾਂ (numbers), ਸਟ੍ਰੀਮਾਂ (io) ਅਤੇ ਇੰਪੋਰਟ ਫਾਈਂਡਰ/ਲੋਡਰ (importlib.abc) ਲਈ ਕਈ ਬਿਲਟ-ਇਨ ABCs ਮੌਜੂਦ ਹਨ। ਤੁਸੀਂ abc ਮੋਡੀਊਲ ਨਾਲ ਆਪਣੀਆਂ ABCs ਵੀ ਬਣਾ ਸਕਦੇ ਹੋ।

ਐਨੋਟੇਟ ਫੰਕਸ਼ਨ

ਇੱਕ callable ਜਿਸਨੂੰ ਕਿਸੇ ਆਬਜੈਕਟ ਦੀਆਂ annotations ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਕਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। Annotate ਫੰਕਸ਼ਨ ਆਮ ਤੌਰ 'ਤੇ functions ਹੁੰਦੇ ਹਨ ਅਤੇ ਫੰਕਸ਼ਨਾਂ, ਕਲਾਸਾਂ ਅਤੇ ਮੋਡੀਊਲਾਂ ਦੇ __annotate__ ਐਟ੍ਰਿਬਿਊਟ ਵਜੋਂ ਆਪਣੇ ਆਪ ਬਣਾਏ ਜਾਂਦੇ ਹਨ। Annotate ਫੰਕਸ਼ਨ evaluate functions ਦਾ ਇੱਕ ਉਪਸਮੂਹ ਹਨ।

ਐਨੋਟੇਸ਼ਨ

ਕਿਸੇ ਵੇਰੀਏਬਲ, ਕਲਾਸ ਐਟ੍ਰਿਬਿਊਟ ਜਾਂ ਫੰਕਸ਼ਨ ਪੈਰਾਮੀਟਰ/ਰਿਟਰਨ ਮੁੱਲ ਨਾਲ ਜੁੜਿਆ ਇੱਕ ਲੇਬਲ, ਜੋ ਰਿਵਾਜ ਅਨੁਸਾਰ type hint ਵਜੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

ਲੋਕਲ ਵੇਰੀਏਬਲਾਂ ਦੀਆਂ ਐਨੋਟੇਸ਼ਨਾਂ ਨੂੰ ਰਨਟਾਈਮ ਦੌਰਾਨ ਐਕਸੈਸ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ, ਪਰ ਗਲੋਬਲ ਵੇਰੀਏਬਲਾਂ, ਕਲਾਸ ਐਟ੍ਰਿਬਿਊਟਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀਆਂ ਐਨੋਟੇਸ਼ਨਾਂ ਨੂੰ ਕ੍ਰਮਵਾਰ ਮੋਡੀਊਲਾਂ, ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਉੱਤੇ annotationlib.get_annotations() ਕਾਲ ਕਰਕੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਇਸ ਕਾਰਜਸ਼ੀਲਤਾ ਦੇ ਵੇਰਵੇ ਲਈ variable annotation, function annotation, PEP 484, PEP 526, ਅਤੇ PEP 649 ਵੇਖੋ। ਐਨੋਟੇਸ਼ਨਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀਆਂ ਵਧੀਆ ਪ੍ਰਥਾਵਾਂ ਲਈ Annotations Best Practices ਵੀ ਵੇਖੋ।

ਆਰਗਿਊਮੈਂਟ

ਕਿਸੇ function (ਜਾਂ method) ਨੂੰ ਕਾਲ ਕਰਨ ਵੇਲੇ ਉਸਨੂੰ ਦਿੱਤਾ ਗਿਆ ਮੁੱਲ। ਆਰਗਿਊਮੈਂਟ ਦੋ ਕਿਸਮਾਂ ਦੇ ਹੁੰਦੇ ਹਨ:

• keyword argument: ਉਹ ਆਰਗਿਊਮੈਂਟ ਜਿਸ ਤੋਂ ਪਹਿਲਾਂ ਕੋਈ ਪਛਾਣਕਰਤਾ (ਜਿਵੇਂ name=) ਦਿੱਤਾ ਗਿਆ ਹੋਵੇ, ਜਾਂ ਜੋ ** ਨਾਲ ਦਿੱਤੀ ਡਿਕਸ਼ਨਰੀ ਦੇ ਮੁੱਲ ਵਜੋਂ ਪਾਸ ਕੀਤਾ ਗਿਆ ਹੋਵੇ। ਉਦਾਹਰਨ ਵਜੋਂ, ਹੇਠਾਂ ਦਿੱਤੀਆਂ complex() ਕਾਲਾਂ ਵਿੱਚ 3 ਅਤੇ 5 ਦੋਵੇਂ ਕੀਵਰਡ ਆਰਗਿਊਮੈਂਟ ਹਨ:

  complex(real=3, imag=5)
  complex(**{'real': 3, 'imag': 5})
  

• positional argument: ਉਹ ਆਰਗਿਊਮੈਂਟ ਜੋ ਕੀਵਰਡ ਆਰਗਿਊਮੈਂਟ ਨਹੀਂ ਹੁੰਦਾ। ਪੋਜ਼ੀਸ਼ਨਲ ਆਰਗਿਊਮੈਂਟ ਆਰਗਿਊਮੈਂਟ ਸੂਚੀ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਆ ਸਕਦੇ ਹਨ ਅਤੇ/ਜਾਂ * ਨਾਲ ਦਿੱਤੇ iterable ਦੇ ਤੱਤਾਂ ਵਜੋਂ ਪਾਸ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਉਦਾਹਰਨ ਵਜੋਂ, ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਕਾਲਾਂ ਵਿੱਚ 3 ਅਤੇ 5 ਦੋਵੇਂ ਪੋਜ਼ੀਸ਼ਨਲ ਆਰਗਿਊਮੈਂਟ ਹਨ:

  complex(3, 5)
  complex(*(3, 5))
  

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

parameter ਸ਼ਬਦਾਵਲੀ ਐਂਟਰੀ, arguments ਅਤੇ parameters ਵਿੱਚ ਅੰਤਰ ਵਾਲਾ FAQ ਪ੍ਰਸ਼ਨ, ਅਤੇ PEP 362 ਵੀ ਵੇਖੋ।

ਅਸਿੰਕ੍ਰੋਨਸ ਕਾਂਟੈਕਸਟ ਮੈਨੇਜਰ

ਇੱਕ ਆਬਜੈਕਟ ਜੋ __aenter__() ਅਤੇ __aexit__() ਮੈਥਡ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ async with ਸਟੇਟਮੈਂਟ ਵਿੱਚ ਦਿੱਖ ਰਹੇ ਵਾਤਾਵਰਣ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦਾ ਹੈ। ਇਹ PEP 492 ਵਿੱਚ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ ਸੀ।

ਅਸਿੰਕ੍ਰੋਨਸ ਜਨਰੇਟਰ

ਸੰਦਰਭ ਅਨੁਸਾਰ ਗੈਰ-ਆਧਿਕਾਰਿਕ ਤੌਰ 'ਤੇ ਇਸਦਾ ਅਰਥ ਜਾਂ ਤਾਂ asynchronous generator function ਜਾਂ asynchronous generator iterator ਹੁੰਦਾ ਹੈ। ਰਸਮੀ ਸ਼ਬਦ asynchronous generator function ਅਤੇ asynchronous generator iterator ਅਮਲ ਵਿੱਚ ਘੱਟ ਵਰਤੇ ਜਾਂਦੇ ਹਨ; ਕੇਵਲ "asynchronous generator" ਕਹਿਣਾ ਲਗਭਗ ਹਰ ਵੇਲੇ ਕਾਫ਼ੀ ਹੁੰਦਾ ਹੈ।

ਅਸਿੰਕ੍ਰੋਨਸ ਜਨਰੇਟਰ ਫੰਕਸ਼ਨ

ਇੱਕ ਫੰਕਸ਼ਨ ਜੋ asynchronous generator iterator ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਹ async def ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ coroutine function ਵਾਂਗ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ, ਪਰ ਇਸ ਵਿੱਚ yield ਐਕਸਪ੍ਰੈਸ਼ਨ ਹੁੰਦੀਆਂ ਹਨ ਜੋ async for ਲੂਪ ਵਿੱਚ ਵਰਤੀ ਜਾ ਸਕਣ ਵਾਲੀਆਂ ਮੁੱਲਾਂ ਦੀ ਲੜੀ ਪੈਦਾ ਕਰਦੀਆਂ ਹਨ। ਵੇਖੋ PEP 525।

ਇੱਕ ਅਸਿੰਕ੍ਰੋਨਸ ਜਨਰੇਟਰ ਫੰਕਸ਼ਨ ਵਿੱਚ await ਐਕਸਪ੍ਰੈਸ਼ਨ ਦੇ ਨਾਲ async for ਅਤੇ async with ਸਟੇਟਮੈਂਟ ਵੀ ਹੋ ਸਕਦੇ ਹਨ।

ਅਸਿੰਕ੍ਰੋਨਸ ਜਨਰੇਟਰ ਇਟਰੇਟਰ

asynchronous generator function ਦੁਆਰਾ ਬਣਾਇਆ ਗਿਆ ਇੱਕ ਆਬਜੈਕਟ।

ਇਹ ਇੱਕ asynchronous iterator ਹੈ ਜੋ __anext__() ਮੈਥਡ ਰਾਹੀਂ ਕਾਲ ਕਰਨ 'ਤੇ ਇੱਕ awaitable ਆਬਜੈਕਟ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜੋ ਅਸਿੰਕ੍ਰੋਨਸ ਜਨਰੇਟਰ ਫੰਕਸ਼ਨ ਦੀ ਬਾਡੀ ਨੂੰ ਅਗਲੇ yield ਐਕਸਪ੍ਰੈਸ਼ਨ ਤੱਕ ਚਲਾਉਂਦਾ ਹੈ।

ਹਰ yield ਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਅਸਥਾਈ ਤੌਰ 'ਤੇ ਰੋਕ ਦਿੰਦਾ ਹੈ ਅਤੇ ਐਗਜ਼ਿਕਿਊਸ਼ਨ ਦੀ ਸਥਿਤੀ (ਲੋਕਲ ਵੇਰੀਏਬਲਾਂ ਅਤੇ ਬਾਕੀ ਰਹੇ try-statements ਸਮੇਤ) ਨੂੰ ਯਾਦ ਰੱਖਦਾ ਹੈ। ਜਦੋਂ asynchronous generator iterator __anext__() ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ ਹੋਰ awaitable ਨਾਲ ਮੁੜ ਚਲਦਾ ਹੈ, ਤਾਂ ਇਹ ਉਥੋਂ ਹੀ ਜਾਰੀ ਰਹਿੰਦਾ ਹੈ ਜਿੱਥੇ ਇਹ ਰੁਕਿਆ ਸੀ। PEP 492 ਅਤੇ PEP 525 ਵੇਖੋ।

ਅਸਿੰਕ੍ਰੋਨਸ ਇਟਰੇਬਲ

ਇੱਕ ਆਬਜੈਕਟ ਜਿਸਨੂੰ async for ਸਟੇਟਮੈਂਟ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਸਦੀ __aiter__() ਮੈਥਡ ਤੋਂ ਇੱਕ asynchronous iterator ਵਾਪਸ ਆਉਣਾ ਲਾਜ਼ਮੀ ਹੈ। ਇਹ PEP 492 ਵਿੱਚ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ ਸੀ।

ਅਸਿੰਕ੍ਰੋਨਸ ਇਟਰੇਟਰ

ਇੱਕ ਆਬਜੈਕਟ ਜੋ __aiter__() ਅਤੇ __anext__() ਮੈਥਡਾਂ ਨੂੰ ਇੰਪਲੀਮੈਂਟ ਕਰਦਾ ਹੈ। __anext__() ਨੂੰ ਇੱਕ awaitable ਆਬਜੈਕਟ ਵਾਪਸ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। async for ਅਸਿੰਕ੍ਰੋਨਸ ਇਟਰੇਟਰ ਦੀ __anext__() ਮੈਥਡ ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ awaitables ਨੂੰ resolve ਕਰਦਾ ਰਹਿੰਦਾ ਹੈ ਜਦ ਤੱਕ ਕਿ StopAsyncIteration ਐਕਸੈਪਸ਼ਨ ਨਾ ਆ ਜਾਵੇ। ਇਹ PEP 492 ਵਿੱਚ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ ਸੀ।

ਐਟਾਮਿਕ ਓਪਰੇਸ਼ਨ

ਇੱਕ ਅਜਿਹਾ ਓਪਰੇਸ਼ਨ ਜੋ ਇੱਕੋ, ਅਟੁੱਟ ਕਦਮ ਵਜੋਂ ਚੱਲਦਾ ਹੋਇਆ ਦਿਸਦਾ ਹੈ। ਕੋਈ ਹੋਰ ਥ੍ਰੈਡ ਇਸਨੂੰ ਅੱਧਾ ਮੁਕੰਮਲ ਹੋਇਆ ਨਹੀਂ ਦੇਖ ਸਕਦਾ ਅਤੇ ਇਸਦੇ ਪ੍ਰਭਾਵ ਇੱਕੋ ਵਾਰ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ। Python ਇਹ ਗਾਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ ਕਿ ਉੱਚ-ਪੱਧਰੀ ਸਟੇਟਮੈਂਟ ਐਟਾਮਿਕ ਹੁੰਦੇ ਹਨ (ਉਦਾਹਰਨ ਵਜੋਂ x += 1 ਕਈ bytecode ਓਪਰੇਸ਼ਨ ਕਰਦਾ ਹੈ ਅਤੇ ਐਟਾਮਿਕ ਨਹੀਂ ਹੈ)। ਐਟਾਮਿਸਿਟੀ ਦੀ ਗਾਰੰਟੀ ਕੇਵਲ ਉਥੇ ਹੁੰਦੀ ਹੈ ਜਿੱਥੇ ਇਹ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਦਸਤਾਵੇਜ਼ਬੱਧ ਕੀਤੀ ਗਈ ਹੋਵੇ। race condition ਅਤੇ data race ਵੀ ਵੇਖੋ।

ਜੁੜੀ ਹੋਈ ਥ੍ਰੈਡ ਸਥਿਤੀ

ਇੱਕ thread state ਜੋ ਮੌਜੂਦਾ OS ਥ੍ਰੈਡ ਲਈ ਸਰਗਰਮ ਹੁੰਦੀ ਹੈ।

ਜਦੋਂ ਕੋਈ thread state ਜੁੜੀ ਹੋਈ ਹੋਵੇ, ਤਾਂ OS ਥ੍ਰੈਡ ਨੂੰ ਪੂਰੀ Python C API ਤੱਕ ਪਹੁੰਚ ਹੁੰਦੀ ਹੈ ਅਤੇ ਉਹ ਸੁਰੱਖਿਅਤ ਤਰੀਕੇ ਨਾਲ bytecode interpreter ਨੂੰ ਚਲਾ ਸਕਦਾ ਹੈ।

ਜਦ ਤੱਕ ਕੋਈ ਫੰਕਸ਼ਨ ਖਾਸ ਤੌਰ 'ਤੇ ਹੋਰ ਨਾ ਕਹੇ, ਜੁੜੀ ਹੋਈ thread state ਤੋਂ ਬਿਨਾਂ C API ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਇੱਕ ਘਾਤਕ ਗਲਤੀ ਜਾਂ ਅਣਪਰਿਭਾਸ਼ਿਤ ਵਿਹਾਰ ਦਾ ਕਾਰਨ ਬਣੇਗੀ। Thread state ਨੂੰ C API ਰਾਹੀਂ ਯੂਜ਼ਰ ਦੁਆਰਾ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਜਾਂ runtime ਦੁਆਰਾ ਅਪਰੋਕਸ਼ ਤੌਰ 'ਤੇ ਜੋੜਿਆ ਜਾਂ ਅਲੱਗ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ blocking C calls ਦੌਰਾਨ ਅਤੇ ਕਾਲਾਂ ਦੇ ਵਿਚਕਾਰ bytecode interpreter ਦੁਆਰਾ ਕੀਤਾ ਗਿਆ ਕੰਮ ਵੀ ਸ਼ਾਮਲ ਹੈ।

Python ਦੇ ਜ਼ਿਆਦਾਤਰ ਬਿਲਡਾਂ ਵਿੱਚ, ਜੁੜੀ ਹੋਈ thread state ਹੋਣ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਕਾਲਰ ਮੌਜੂਦਾ interpreter ਲਈ GIL ਰੱਖਦਾ ਹੈ, ਇਸ ਲਈ ਕਿਸੇ ਵੀ ਸਮੇਂ ਕੇਵਲ ਇੱਕ OS thread ਹੀ ਜੁੜੀ ਹੋਈ thread state ਰੱਖ ਸਕਦਾ ਹੈ। Python ਦੇ free-threaded builds ਵਿੱਚ, threads ਇੱਕੋ ਸਮੇਂ ਜੁੜੀ ਹੋਈ thread state ਰੱਖ ਸਕਦੇ ਹਨ, ਜਿਸ ਨਾਲ bytecode interpreter ਦੀ ਅਸਲ ਸਮਾਂਤਰ ਕਾਰਗੁਜ਼ਾਰੀ (parallelism) ਸੰਭਵ ਹੁੰਦੀ ਹੈ।

ਐਟ੍ਰਿਬਿਊਟ

ਕਿਸੇ ਆਬਜੈਕਟ ਨਾਲ ਸੰਬੰਧਿਤ ਇੱਕ ਮੁੱਲ ਜਿਸਨੂੰ ਆਮ ਤੌਰ 'ਤੇ dotted expressions ਰਾਹੀਂ ਨਾਮ ਨਾਲ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, ਜੇ ਕਿਸੇ ਆਬਜੈਕਟ o ਦਾ ਇੱਕ ਐਟ੍ਰਿਬਿਊਟ a ਹੋਵੇ, ਤਾਂ ਇਸਨੂੰ o.a ਵਜੋਂ ਦਰਸਾਇਆ ਜਾਵੇਗਾ।

ਜੇ ਆਬਜੈਕਟ ਇਸਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੋਵੇ, ਤਾਂ ਉਸਨੂੰ ਅਜਿਹਾ ਐਟ੍ਰਿਬਿਊਟ ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜਿਸਦਾ ਨਾਮ Names (identifiers and keywords) ਅਨੁਸਾਰ ਇੱਕ identifier ਨਾ ਹੋਵੇ, ਉਦਾਹਰਨ ਵਜੋਂ setattr() ਦੀ ਵਰਤੋਂ ਕਰਕੇ। ਅਜਿਹਾ ਐਟ੍ਰਿਬਿਊਟ dotted expression ਰਾਹੀਂ ਐਕਸੈਸ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕੇਗਾ ਅਤੇ ਇਸਨੂੰ getattr() ਨਾਲ ਪ੍ਰਾਪਤ ਕਰਨਾ ਪਵੇਗਾ।

awaitable

ਇੱਕ ਆਬਜੈਕਟ ਜਿਸਨੂੰ await ਐਕਸਪ੍ਰੈਸ਼ਨ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ coroutine ਜਾਂ __await__() ਮੈਥਡ ਵਾਲਾ ਆਬਜੈਕਟ ਹੋ ਸਕਦਾ ਹੈ। PEP 492 ਵੀ ਵੇਖੋ।

BDFL

Benevolent Dictator For Life (ਜੀਵਨ ਭਰ ਲਈ ਉਦਾਰ ਤਾਨਾਸ਼ਾਹ), ਅਰਥਾਤ Guido van Rossum, ਜੋ Python ਦੇ ਸਿਰਜਣਹਾਰ ਹਨ।

ਬਾਈਨਰੀ ਫਾਈਲ

ਇੱਕ file object ਜੋ bytes-like objects ਨੂੰ ਪੜ੍ਹ ਅਤੇ ਲਿਖ ਸਕਦਾ ਹੈ। ਬਾਈਨਰੀ ਫਾਈਲਾਂ ਦੀਆਂ ਉਦਾਹਰਨਾਂ ਵਿੱਚ ਬਾਈਨਰੀ ਮੋਡ ('rb', 'wb' ਜਾਂ 'rb+') ਵਿੱਚ ਖੋਲ੍ਹੀਆਂ ਫਾਈਲਾਂ, sys.stdin.buffer, sys.stdout.buffer, ਅਤੇ io.BytesIO ਅਤੇ gzip.GzipFile ਦੇ ਇੰਸਟੈਂਸ ਸ਼ਾਮਲ ਹਨ।

str ਆਬਜੈਕਟਾਂ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਯੋਗ file object ਲਈ text file ਵੀ ਵੇਖੋ।

ਉਧਾਰ ਲਿਆ ਰੈਫਰੈਂਸ

Python ਦੀ C API ਵਿੱਚ, borrowed reference ਕਿਸੇ ਆਬਜੈਕਟ ਲਈ ਅਜਿਹਾ ਰੈਫਰੈਂਸ ਹੁੰਦਾ ਹੈ ਜਿਸਦੀ ਮਲਕੀਅਤ ਉਸ ਕੋਡ ਕੋਲ ਨਹੀਂ ਹੁੰਦੀ ਜੋ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰ ਰਿਹਾ ਹੈ। ਜੇ ਆਬਜੈਕਟ ਨਸ਼ਟ ਹੋ ਜਾਵੇ ਤਾਂ ਇਹ dangling pointer ਬਣ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, garbage collection ਆਬਜੈਕਟ ਦਾ ਆਖਰੀ strong reference ਹਟਾ ਸਕਦੀ ਹੈ ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਉਸਨੂੰ ਨਸ਼ਟ ਕਰ ਸਕਦੀ ਹੈ।

borrowed reference ਨੂੰ ਥਾਂ 'ਤੇ ਹੀ strong reference ਵਿੱਚ ਬਦਲਣ ਲਈ Py_INCREF() ਕਾਲ ਕਰਨਾ ਸਿਫਾਰਸ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਸਿਵਾਏ ਉਸ ਸਥਿਤੀ ਦੇ ਜਦੋਂ borrowed reference ਦੀ ਆਖਰੀ ਵਰਤੋਂ ਤੋਂ ਪਹਿਲਾਂ ਆਬਜੈਕਟ ਨਸ਼ਟ ਨਹੀਂ ਹੋ ਸਕਦਾ। ਨਵਾਂ strong reference ਬਣਾਉਣ ਲਈ Py_NewRef() ਫੰਕਸ਼ਨ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਬਾਈਟਸ-ਸਮਾਨ ਆਬਜੈਕਟ

ਇੱਕ ਆਬਜੈਕਟ ਜੋ Buffer Protocol ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ C-contiguous ਬਫਰ ਨਿਰਯਾਤ ਕਰ ਸਕਦਾ ਹੈ। ਇਸ ਵਿੱਚ ਸਾਰੇ bytes, bytearray, ਅਤੇ array.array ਆਬਜੈਕਟ ਸ਼ਾਮਲ ਹਨ, ਨਾਲ ਹੀ ਕਈ ਆਮ memoryview ਆਬਜੈਕਟ ਵੀ। ਬਾਈਟਸ-ਸਮਾਨ ਆਬਜੈਕਟ ਬਾਈਨਰੀ ਡਾਟਾ ਨਾਲ ਕੰਮ ਕਰਨ ਵਾਲੀਆਂ ਵੱਖ-ਵੱਖ ਕਾਰਵਾਈਆਂ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ; ਇਨ੍ਹਾਂ ਵਿੱਚ ਸੰਕੁਚਨ (compression), ਬਾਈਨਰੀ ਫਾਈਲ ਵਿੱਚ ਸੇਵ ਕਰਨਾ ਅਤੇ ਸਾਕੇਟ ਰਾਹੀਂ ਭੇਜਣਾ ਸ਼ਾਮਲ ਹੈ।

ਕੁਝ ਕਾਰਵਾਈਆਂ ਲਈ ਬਾਈਨਰੀ ਡਾਟਾ mutable ਹੋਣਾ ਲਾਜ਼ਮੀ ਹੁੰਦਾ ਹੈ। ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਇਨ੍ਹਾਂ ਨੂੰ ਅਕਸਰ "read-write bytes-like objects" ਕਿਹਾ ਜਾਂਦਾ ਹੈ। Mutable ਬਫਰ ਆਬਜੈਕਟਾਂ ਦੀਆਂ ਉਦਾਹਰਨਾਂ ਵਿੱਚ bytearray ਅਤੇ bytearray ਦਾ memoryview ਸ਼ਾਮਲ ਹਨ। ਹੋਰ ਕਾਰਵਾਈਆਂ ਲਈ ਬਾਈਨਰੀ ਡਾਟਾ immutable ਆਬਜੈਕਟਾਂ ("read-only bytes-like objects") ਵਿੱਚ ਸਟੋਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ; ਇਨ੍ਹਾਂ ਦੀਆਂ ਉਦਾਹਰਨਾਂ bytes ਅਤੇ bytes ਆਬਜੈਕਟ ਦਾ memoryview ਹਨ।

ਬਾਈਟਕੋਡ

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

ਬਾਈਟਕੋਡ ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਸੂਚੀ the dis module ਦੇ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਮਿਲ ਸਕਦੀ ਹੈ।

ਕਾਲਯੋਗ

ਕਾਲਯੋਗ (callable) ਉਹ ਆਬਜੈਕਟ ਹੁੰਦਾ ਹੈ ਜਿਸਨੂੰ ਕਾਲ ਕੀਤਾ ਜਾ ਸਕੇ, ਸੰਭਵ ਤੌਰ 'ਤੇ ਕੁਝ ਆਰਗਿਊਮੈਂਟਾਂ (ਵੇਖੋ argument) ਨਾਲ, ਹੇਠਾਂ ਦਿੱਤੇ ਸਿੰਟੈਕਸ ਅਨੁਸਾਰ:

callable(argument1, argument2, argumentN)

ਇੱਕ function, ਅਤੇ ਇਸਦੇ ਵਿਸਥਾਰ ਵਜੋਂ ਇੱਕ method, ਕਾਲਯੋਗ ਹੁੰਦਾ ਹੈ। ਕਿਸੇ ਕਲਾਸ ਦਾ ਉਹ ਇੰਸਟੈਂਸ ਜੋ __call__() ਮੈਥਡ ਨੂੰ ਇੰਪਲੀਮੈਂਟ ਕਰਦਾ ਹੋਵੇ, ਉਹ ਵੀ ਕਾਲਯੋਗ ਹੁੰਦਾ ਹੈ।

ਕਾਲਬੈਕ

ਇੱਕ ਸਬਰੂਟੀਨ ਫੰਕਸ਼ਨ ਜੋ ਭਵਿੱਖ ਵਿੱਚ ਕਿਸੇ ਸਮੇਂ ਚਲਾਉਣ ਲਈ ਆਰਗਿਊਮੈਂਟ ਵਜੋਂ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਕਲਾਸ

ਯੂਜ਼ਰ-ਪਰਿਭਾਸ਼ਿਤ ਆਬਜੈਕਟ ਬਣਾਉਣ ਲਈ ਇੱਕ ਖਾਕਾ (template)। ਕਲਾਸ ਪਰਿਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਮੈਥਡ ਪਰਿਭਾਸ਼ਾਵਾਂ ਹੁੰਦੀਆਂ ਹਨ ਜੋ ਕਲਾਸ ਦੇ ਇੰਸਟੈਂਸਾਂ ਉੱਤੇ ਕੰਮ ਕਰਦੀਆਂ ਹਨ।

ਕਲਾਸ ਵੇਰੀਏਬਲ

ਕਲਾਸ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਇੱਕ ਵੇਰੀਏਬਲ ਜਿਸਨੂੰ ਕੇਵਲ ਕਲਾਸ ਪੱਧਰ 'ਤੇ ਹੀ ਬਦਲਣ ਲਈ ਬਣਾਇਆ ਗਿਆ ਹੋਵੇ (ਅਰਥਾਤ ਕਲਾਸ ਦੇ ਇੰਸਟੈਂਸ ਵਿੱਚ ਨਹੀਂ)।

ਕਲੋਜ਼ਰ ਵੇਰੀਏਬਲ

nested scope ਵਿੱਚੋਂ ਹਵਾਲਾ ਦਿੱਤਾ ਗਿਆ ਇੱਕ free variable ਜੋ ਕਿਸੇ ਬਾਹਰੀ ਸਕੋਪ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਹੁੰਦਾ ਹੈ, ਨਾ ਕਿ ਰਨਟਾਈਮ ਦੌਰਾਨ globals ਜਾਂ builtin namespaces ਤੋਂ ਹੱਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਲਿਖਣ ਦੀ ਪਹੁੰਚ ਦੇਣ ਲਈ ਇਸਨੂੰ nonlocal ਕੀਵਰਡ ਨਾਲ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਾਂ ਜੇ ਵੇਰੀਏਬਲ ਸਿਰਫ਼ ਪੜ੍ਹਿਆ ਜਾ ਰਿਹਾ ਹੋਵੇ ਤਾਂ ਅਪਰੋਕਸ਼ ਤੌਰ 'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।

ਉਦਾਹਰਨ ਵਜੋਂ, ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਵਿੱਚ inner ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ x ਅਤੇ print ਦੋਵੇਂ free variables ਹਨ, ਪਰ ਕੇਵਲ x ਇੱਕ closure variable ਹੈ:

def outer():
    x = 0
    def inner():
        nonlocal x
        x += 1
        print(x)
    return inner

codeobject.co_freevars ਐਟ੍ਰਿਬਿਊਟ ਦੇ ਕਾਰਨ (ਜੋ ਆਪਣੇ ਨਾਮ ਦੇ ਬਾਵਜੂਦ ਸਾਰੇ referenced free variables ਦੀ ਸੂਚੀ ਨਹੀਂ ਦਿੰਦਾ, ਸਗੋਂ ਕੇਵਲ closure variables ਦੇ ਨਾਮ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ), ਵਧੇਰੇ ਆਮ free variable ਸ਼ਬਦ ਕਈ ਵਾਰ ਉਸ ਵੇਲੇ ਵੀ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਅਸਲ ਮਤਲਬ ਖਾਸ ਤੌਰ 'ਤੇ closure variables ਵੱਲ ਸੰਕੇਤ ਕਰਨਾ ਹੋਵੇ।

ਕੰਪਲੈਕਸ ਸੰਖਿਆ

ਜਾਣੀ-ਪਛਾਣੀ ਵਾਸਤਵਿਕ ਸੰਖਿਆ ਪ੍ਰਣਾਲੀ ਦਾ ਇੱਕ ਵਿਸਥਾਰ, ਜਿਸ ਵਿੱਚ ਹਰ ਸੰਖਿਆ ਨੂੰ ਇੱਕ ਵਾਸਤਵਿਕ ਭਾਗ ਅਤੇ ਇੱਕ ਕਾਲਪਨਿਕ ਭਾਗ ਦੇ ਜੋੜ ਵਜੋਂ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ। ਕਾਲਪਨਿਕ ਸੰਖਿਆਵਾਂ ਕਾਲਪਨਿਕ ਇਕਾਈ (-1 ਦਾ ਵਰਗਮੂਲ) ਦੇ ਵਾਸਤਵਿਕ ਗੁਣਾਕ ਹੁੰਦੀਆਂ ਹਨ, ਜਿਨ੍ਹਾਂ ਨੂੰ ਗਣਿਤ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ i ਅਤੇ ਇੰਜੀਨੀਅਰਿੰਗ ਵਿੱਚ j ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ। Python ਵਿੱਚ complex numbers ਲਈ built-in ਸਮਰਥਨ ਹੈ, ਜਿੱਥੇ ਕਾਲਪਨਿਕ ਭਾਗ ਨੂੰ j suffix ਨਾਲ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ, ਉਦਾਹਰਨ ਵਜੋਂ 3+1j। math ਮੋਡੀਊਲ ਦੇ complex ਸਮਕੱਖ ਲਈ cmath ਵਰਤੋ। Complex numbers ਦਾ ਉਪਯੋਗ ਇੱਕ ਉੱਚ ਪੱਧਰੀ ਗਣਿਤੀ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ। ਜੇ ਤੁਹਾਨੂੰ ਇਨ੍ਹਾਂ ਦੀ ਲੋੜ ਬਾਰੇ ਪਤਾ ਨਹੀਂ ਹੈ, ਤਾਂ ਸੰਭਵ ਹੈ ਕਿ ਤੁਸੀਂ ਇਨ੍ਹਾਂ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰ ਸਕਦੇ ਹੋ।

ਸਮਕਾਲੀ ਕਾਰਗੁਜ਼ਾਰੀ

ਕਿਸੇ ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮ ਦੀ ਇੱਕੋ ਸਮੇਂ ਕਈ ਕੰਮ ਕਰਨ ਦੀ ਸਮਰੱਥਾ। Python ਵੱਖ-ਵੱਖ ਤਰ੍ਹਾਂ ਦੀ concurrency ਵਰਤਣ ਵਾਲੇ ਪ੍ਰੋਗਰਾਮ ਲਿਖਣ ਲਈ ਲਾਇਬ੍ਰੇਰੀਆਂ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। asyncio asynchronous tasks ਅਤੇ coroutines ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਹੈ। threading ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ threads ਤੱਕ ਪਹੁੰਚ ਦਿੰਦਾ ਹੈ ਅਤੇ multiprocessing ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ processes ਤੱਕ। Multi-core ਪ੍ਰੋਸੈਸਰ ਇੱਕੋ ਸਮੇਂ ਵੱਖ-ਵੱਖ CPU cores ਉੱਤੇ threads ਅਤੇ processes ਚਲਾ ਸਕਦੇ ਹਨ (ਵੇਖੋ parallelism)।

ਸਮਕਾਲੀ ਸੋਧ

ਜਦੋਂ ਕਈ threads ਇੱਕੋ ਸਮੇਂ ਸਾਂਝੇ ਡਾਟੇ ਵਿੱਚ ਸੋਧ ਕਰਦੇ ਹਨ। ਠੀਕ synchronization ਤੋਂ ਬਿਨਾਂ concurrent modification race conditions ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੀ ਹੈ ਅਤੇ data race, ਡਾਟਾ ਖਰਾਬੀ ਜਾਂ ਦੋਵੇਂ ਪੈਦਾ ਕਰ ਸਕਦੀ ਹੈ।

ਸੰਦਰਭ

ਇਸ ਸ਼ਬਦ ਦੇ ਅਰਥ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ ਕਿ ਇਸਨੂੰ ਕਿੱਥੇ ਅਤੇ ਕਿਵੇਂ ਵਰਤਿਆ ਗਿਆ ਹੈ। ਕੁਝ ਆਮ ਅਰਥ ਇਹ ਹਨ:

• with ਸਟੇਟਮੈਂਟ ਰਾਹੀਂ ਕਿਸੇ context manager ਦੁਆਰਾ ਸਥਾਪਿਤ ਕੀਤੀ ਅਸਥਾਈ ਸਥਿਤੀ ਜਾਂ ਵਾਤਾਵਰਣ।

• ਕਿਸੇ ਖਾਸ contextvars.Context ਆਬਜੈਕਟ ਨਾਲ ਸੰਬੰਧਿਤ key-value bindings ਦਾ ਸੰਗ੍ਰਹਿ, ਜਿਸਨੂੰ ContextVar ਆਬਜੈਕਟਾਂ ਰਾਹੀਂ ਐਕਸੈਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। context variable ਵੀ ਵੇਖੋ।

• ਇੱਕ contextvars.Context ਆਬਜੈਕਟ। current context ਵੀ ਵੇਖੋ।

ਕਾਂਟੈਕਸਟ ਮੈਨੇਜਮੈਂਟ ਪ੍ਰੋਟੋਕੋਲ

with ਸਟੇਟਮੈਂਟ ਦੁਆਰਾ ਕਾਲ ਕੀਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ __enter__() ਅਤੇ __exit__() ਮੈਥਡਾਂ। PEP 343 ਵੇਖੋ।

ਕਾਂਟੈਕਸਟ ਮੈਨੇਜਰ

ਇੱਕ ਆਬਜੈਕਟ ਜੋ context management protocol ਨੂੰ ਇੰਪਲੀਮੈਂਟ ਕਰਦਾ ਹੈ ਅਤੇ with ਸਟੇਟਮੈਂਟ ਵਿੱਚ ਦਿੱਖ ਰਹੇ ਵਾਤਾਵਰਣ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦਾ ਹੈ। PEP 343 ਵੇਖੋ।

ਕਾਂਟੈਕਸਟ ਵੇਰੀਏਬਲ

ਇੱਕ ਐਸਾ ਵੇਰੀਏਬਲ ਜਿਸਦੀ value ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ ਕਿ ਕਿਹੜਾ context current context ਹੈ। Values ਨੂੰ contextvars.ContextVar ਆਬਜੈਕਟਾਂ ਰਾਹੀਂ ਐਕਸੈਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। Context variables ਮੁੱਖ ਤੌਰ 'ਤੇ ਸਮਕਾਲੀ asynchronous tasks ਦੇ ਵਿਚਕਾਰ state ਨੂੰ ਅਲੱਗ ਰੱਖਣ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ।

ਲਗਾਤਾਰ

ਇੱਕ buffer ਨੂੰ contiguous ਤਦੋਂ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ ਜੇ ਉਹ C-contiguous ਜਾਂ Fortran contiguous ਹੋਵੇ। Zero-dimensional buffers ਦੋਵੇਂ C ਅਤੇ Fortran contiguous ਹੁੰਦੇ ਹਨ। One-dimensional arrays ਵਿੱਚ items ਮੈਮੋਰੀ ਵਿੱਚ ਇੱਕ-ਦੂਜੇ ਦੇ ਨਾਲ ਅਤੇ zero ਤੋਂ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲੇ indexes ਦੇ ਕ੍ਰਮ ਅਨੁਸਾਰ ਰੱਖੇ ਜਾਂਦੇ ਹਨ। Multidimensional C-contiguous arrays ਵਿੱਚ memory address ਦੇ ਕ੍ਰਮ ਅਨੁਸਾਰ ਚਲਣ ਵੇਲੇ ਆਖਰੀ index ਸਭ ਤੋਂ ਤੇਜ਼ੀ ਨਾਲ ਬਦਲਦਾ ਹੈ। ਪਰ Fortran contiguous arrays ਵਿੱਚ ਪਹਿਲਾ index ਸਭ ਤੋਂ ਤੇਜ਼ੀ ਨਾਲ ਬਦਲਦਾ ਹੈ।

ਕੋਰੂਟੀਨ

Coroutines subroutines ਦਾ ਇੱਕ ਹੋਰ ਵਿਆਪਕ ਰੂਪ ਹਨ। Subroutine ਇੱਕ ਬਿੰਦੂ ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ ਅਤੇ ਦੂਜੇ ਬਿੰਦੂ 'ਤੇ ਸਮਾਪਤ ਹੁੰਦੀ ਹੈ। Coroutines ਨੂੰ ਕਈ ਵੱਖ-ਵੱਖ ਬਿੰਦੂਆਂ 'ਤੇ ਸ਼ੁਰੂ, ਰੋਕਿਆ ਅਤੇ ਮੁੜ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਨ੍ਹਾਂ ਨੂੰ async def ਸਟੇਟਮੈਂਟ ਨਾਲ ਇੰਪਲੀਮੈਂਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। PEP 492 ਵੀ ਵੇਖੋ।

ਕੋਰੂਟੀਨ ਫੰਕਸ਼ਨ

ਇੱਕ ਐਸਾ ਫੰਕਸ਼ਨ ਜੋ coroutine ਆਬਜੈਕਟ ਵਾਪਸ ਕਰਦਾ ਹੈ। Coroutine function ਨੂੰ async def ਸਟੇਟਮੈਂਟ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਇਸ ਵਿੱਚ await, async for ਅਤੇ async with ਕੀਵਰਡ ਹੋ ਸਕਦੇ ਹਨ। ਇਹ PEP 492 ਦੁਆਰਾ ਪੇਸ਼ ਕੀਤੇ ਗਏ ਸਨ।

CPython

Python ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੀ ਮਿਆਰੀ implementation, ਜੋ python.org ਰਾਹੀਂ ਵੰਡ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। "CPython" ਸ਼ਬਦ ਇਸ implementation ਨੂੰ Jython ਜਾਂ IronPython ਵਰਗੀਆਂ ਹੋਰ implementations ਤੋਂ ਵੱਖ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

ਮੌਜੂਦਾ ਕਾਂਟੈਕਸਟ

ਉਹ context (contextvars.Context ਆਬਜੈਕਟ) ਜੋ ਇਸ ਵੇਲੇ ContextVar ਆਬਜੈਕਟਾਂ ਦੁਆਰਾ context variables ਦੀਆਂ values ਨੂੰ (ਪ੍ਰਾਪਤ ਕਰਨ ਜਾਂ ਸੈੱਟ ਕਰਨ) ਲਈ ਵਰਤਿਆ ਜਾ ਰਿਹਾ ਹੈ। ਹਰ thread ਦਾ ਆਪਣਾ current context ਹੁੰਦਾ ਹੈ। Asynchronous tasks ਚਲਾਉਣ ਵਾਲੇ frameworks (ਵੇਖੋ asyncio) ਹਰ task ਨੂੰ ਇੱਕ context ਨਾਲ ਜੋੜਦੇ ਹਨ ਜੋ task ਦੇ ਸ਼ੁਰੂ ਹੋਣ ਜਾਂ ਮੁੜ ਚੱਲਣ 'ਤੇ current context ਬਣ ਜਾਂਦਾ ਹੈ।

ਚੱਕਰੀ ਅਲੱਗ ਸਮੂਹ

ਇੱਕ ਜਾਂ ਵੱਧ ਆਬਜੈਕਟਾਂ ਦਾ ਉਪਸਮੂਹ ਜੋ ਆਪਸ ਵਿੱਚ reference cycle ਰਾਹੀਂ ਇੱਕ-ਦੂਜੇ ਨੂੰ ਰੈਫਰ ਕਰਦੇ ਹਨ, ਪਰ ਸਮੂਹ ਤੋਂ ਬਾਹਰਲੇ ਆਬਜੈਕਟਾਂ ਦੁਆਰਾ ਰੈਫਰ ਨਹੀਂ ਕੀਤੇ ਜਾਂਦੇ। cyclic garbage collector ਦਾ ਉਦੇਸ਼ ਅਜਿਹੇ ਸਮੂਹਾਂ ਦੀ ਪਛਾਣ ਕਰਨਾ ਅਤੇ reference cycles ਨੂੰ ਤੋੜਨਾ ਹੈ ਤਾਂ ਜੋ ਮੈਮੋਰੀ ਮੁੜ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾ ਸਕੇ।

ਡਾਟਾ ਰੇਸ

ਇਹੋ ਜਿਹੀ ਸਥਿਤੀ ਜਿੱਥੇ ਕਈ threads ਇੱਕੋ ਮੈਮੋਰੀ ਸਥਾਨ ਨੂੰ ਇੱਕੋ ਸਮੇਂ ਐਕਸੈਸ ਕਰਦੀਆਂ ਹਨ, ਘੱਟੋ-ਘੱਟ ਇੱਕ ਐਕਸੈਸ write ਹੁੰਦੀ ਹੈ, ਅਤੇ threads ਆਪਣੇ ਐਕਸੈਸ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਕੋਈ synchronization ਨਹੀਂ ਵਰਤਦੀਆਂ। Data races non-deterministic ਵਿਹਾਰ ਪੈਦਾ ਕਰਦੀਆਂ ਹਨ ਅਤੇ ਡਾਟਾ ਖਰਾਬ ਹੋਣ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੀਆਂ ਹਨ। locks ਅਤੇ ਹੋਰ synchronization primitives ਦੀ ਸਹੀ ਵਰਤੋਂ data races ਨੂੰ ਰੋਕਦੀ ਹੈ। ਧਿਆਨ ਰਹੇ ਕਿ data races ਸਿਰਫ native code ਵਿੱਚ ਹੀ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਪਰ native code Python API ਰਾਹੀਂ ਉਪਲਬਧ ਹੋ ਸਕਦਾ ਹੈ। race condition ਅਤੇ thread-safe ਵੀ ਵੇਖੋ।

ਡੈਡਲਾਕ

ਇਹੋ ਜਿਹੀ ਸਥਿਤੀ ਜਿਸ ਵਿੱਚ ਦੋ ਜਾਂ ਵੱਧ tasks (threads, processes ਜਾਂ coroutines) ਇੱਕ-ਦੂਜੇ ਵੱਲੋਂ resources ਛੱਡਣ ਜਾਂ ਕਾਰਵਾਈ ਪੂਰੀ ਕਰਨ ਦੀ ਅਣਮਿਆਦੀ ਉਡੀਕ ਕਰਦੀਆਂ ਹਨ, ਜਿਸ ਕਾਰਨ ਕੋਈ ਵੀ ਅੱਗੇ ਨਹੀਂ ਵੱਧ ਸਕਦਾ। ਉਦਾਹਰਨ ਲਈ, ਜੇ thread A lock 1 ਰੱਖਦੀ ਹੈ ਅਤੇ lock 2 ਦੀ ਉਡੀਕ ਕਰਦੀ ਹੈ, ਜਦਕਿ thread B lock 2 ਰੱਖਦੀ ਹੈ ਅਤੇ lock 1 ਦੀ ਉਡੀਕ ਕਰਦੀ ਹੈ, ਤਾਂ ਦੋਵੇਂ threads ਅਣਮਿਆਦੀ ਉਡੀਕ ਕਰਨਗੀਆਂ। Python ਵਿੱਚ ਇਹ ਅਕਸਰ ਵੱਖਰੇ ਕ੍ਰਮਾਂ ਵਿੱਚ ਕਈ locks ਪ੍ਰਾਪਤ ਕਰਨ ਜਾਂ circular join/await dependencies ਕਾਰਨ ਹੁੰਦਾ ਹੈ। Deadlocks ਤੋਂ ਬਚਣ ਲਈ ਹਮੇਸ਼ਾਂ ਕਈ locks ਨੂੰ ਇਕਸਾਰ ਕ੍ਰਮ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। lock ਅਤੇ reentrant ਵੀ ਵੇਖੋ।

ਡੈਕੋਰੇਟਰ

ਇੱਕ ਫੰਕਸ਼ਨ ਜੋ ਦੂਜਾ ਫੰਕਸ਼ਨ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਆਮ ਤੌਰ 'ਤੇ ਫੰਕਸ਼ਨ ਟ੍ਰਾਂਸਫਾਰਮੇਸ਼ਨ ਵਜੋਂ @wrapper ਸਿਨਟੈਕਸ ਰਾਹੀਂ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਡੈਕੋਰੇਟਰਾਂ ਲਈ ਆਮ ਉਦਾਹਰਣਾਂ ਹਨ @classmethod ਅਤੇ @staticmethod ।

Decorator syntax ਸਿਰਫ syntactic sugar ਹੈ; ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਦੋਵੇਂ function definitions ਅਰਥਾਤਮਕ ਤੌਰ 'ਤੇ ਇਕੋ ਜਿਹੀਆਂ ਹਨ:

def f(arg):
    ...
f = staticmethod(f)

@staticmethod
def f(arg):
    ...

ਇਹੀ ਧਾਰਣਾ classes ਲਈ ਵੀ ਮੌਜੂਦ ਹੈ, ਪਰ ਉੱਥੇ ਇਸਦੀ ਵਰਤੋਂ ਘੱਟ ਹੁੰਦੀ ਹੈ। Decorators ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ function definitions ਅਤੇ class definitions ਦੇ ਦਸਤਾਵੇਜ਼ ਵੇਖੋ।

ਡਿਸਕ੍ਰਿਪਟਰ

ਕੋਈ ਵੀ ਆਬਜੈਕਟ ਜੋ __get__(), __set__(), ਜਾਂ __delete__() ਮੈਥਡ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਕਿਸੇ ਕਲਾਸ ਦਾ attribute ਇੱਕ descriptor ਹੁੰਦਾ ਹੈ, ਤਾਂ attribute lookup ਦੌਰਾਨ ਇਸਦਾ ਵਿਸ਼ੇਸ਼ binding ਵਿਹਾਰ ਚਾਲੂ ਹੋ ਜਾਂਦਾ ਹੈ। ਆਮ ਤੌਰ 'ਤੇ a.b ਰਾਹੀਂ attribute ਪ੍ਰਾਪਤ, ਸੈੱਟ ਜਾਂ ਮਿਟਾਉਣ ਵੇਲੇ a ਦੀ class dictionary ਵਿੱਚ b ਨਾਮ ਵਾਲਾ ਆਬਜੈਕਟ ਲੱਭਿਆ ਜਾਂਦਾ ਹੈ, ਪਰ ਜੇ b ਇੱਕ descriptor ਹੋਵੇ, ਤਾਂ ਸੰਬੰਧਿਤ descriptor ਮੈਥਡ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। Descriptors ਨੂੰ ਸਮਝਣਾ Python ਦੀ ਡੂੰਘੀ ਸਮਝ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਇਹ functions, methods, properties, class methods, static methods ਅਤੇ super classes ਦੇ ਹਵਾਲਿਆਂ ਸਮੇਤ ਕਈ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਾ ਆਧਾਰ ਹਨ।

Descriptors ਦੇ ਮੈਥਡਾਂ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ Implementing Descriptors ਜਾਂ Descriptor How To Guide ਵੇਖੋ।

ਡਿਕਸ਼ਨਰੀ

ਇੱਕ associative array, ਜਿਸ ਵਿੱਚ ਮਨਚਾਹੀਆਂ keys ਨੂੰ values ਨਾਲ ਮੈਪ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। Keys ਕੋਈ ਵੀ ਆਬਜੈਕਟ ਹੋ ਸਕਦੀਆਂ ਹਨ ਜਿਨ੍ਹਾਂ ਵਿੱਚ __hash__() ਅਤੇ __eq__() ਮੈਥਡ ਮੌਜੂਦ ਹੋਣ। Perl ਵਿੱਚ ਇਸਨੂੰ hash ਕਿਹਾ ਜਾਂਦਾ ਹੈ।

ਡਿਕਸ਼ਨਰੀ ਕੰਪ੍ਰਿਹੈਂਸ਼ਨ

ਕਿਸੇ iterable ਦੇ ਸਾਰੇ ਜਾਂ ਕੁਝ elements ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਕੇ ਨਤੀਜਿਆਂ ਵਾਲੀ dictionary ਵਾਪਸ ਕਰਨ ਦਾ ਸੰਖੇਪ ਤਰੀਕਾ। results = {n: n ** 2 for n in range(10)} ਇੱਕ dictionary ਬਣਾਉਂਦਾ ਹੈ ਜਿਸ ਵਿੱਚ key n ਨੂੰ value n ** 2 ਨਾਲ ਮੈਪ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। Comprehensions ਵੇਖੋ।

ਡਿਕਸ਼ਨਰੀ ਵਿਊ

dict.keys(), dict.values(), ਅਤੇ dict.items() ਤੋਂ ਵਾਪਸ ਆਉਣ ਵਾਲੇ ਆਬਜੈਕਟਾਂ ਨੂੰ dictionary views ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਇਹ dictionary ਦੀਆਂ entries ਦਾ dynamic view ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਜਦੋਂ dictionary ਬਦਲਦੀ ਹੈ ਤਾਂ view ਵੀ ਉਹ ਬਦਲਾਅ ਦਰਸਾਉਂਦਾ ਹੈ। Dictionary view ਨੂੰ ਪੂਰੀ list ਵਿੱਚ ਬਦਲਣ ਲਈ list(dictview) ਵਰਤੋ। Dictionary view objects ਵੇਖੋ।

ਡੌਕਸਟ੍ਰਿੰਗ

ਇੱਕ string literal ਜੋ ਕਿਸੇ class, function ਜਾਂ module ਵਿੱਚ ਪਹਿਲੇ expression ਵਜੋਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ। ਭਾਵੇਂ suite ਦੇ ਚਲਣ ਦੌਰਾਨ ਇਸਨੂੰ ਅਣਡਿੱਠਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਪਰ compiler ਇਸਨੂੰ ਪਛਾਣਦਾ ਹੈ ਅਤੇ enclosing class, function ਜਾਂ module ਦੇ __doc__ attribute ਵਿੱਚ ਸੰਭਾਲ ਦਿੰਦਾ ਹੈ। ਕਿਉਂਕਿ ਇਹ introspection ਰਾਹੀਂ ਉਪਲਬਧ ਹੁੰਦਾ ਹੈ, ਇਸ ਲਈ ਇਹ ਆਬਜੈਕਟ ਦੀ documentation ਲਈ ਮਿਆਰੀ ਥਾਂ ਹੈ।

ਡੱਕ-ਟਾਈਪਿੰਗ

ਇੱਕ programming ਸ਼ੈਲੀ ਜੋ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਆਬਜੈਕਟ ਦੀ type ਨਹੀਂ ਵੇਖਦੀ ਕਿ ਉਸ ਕੋਲ ਸਹੀ interface ਹੈ ਜਾਂ ਨਹੀਂ; ਇਸ ਦੀ ਬਜਾਏ method ਜਾਂ attribute ਨੂੰ ਸਿੱਧਾ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ("ਜੇ ਇਹ ਬਤਖ਼ ਵਾਂਗ ਲੱਗਦੀ ਹੈ ਅਤੇ ਬਤਖ਼ ਵਾਂਗ ਆਵਾਜ਼ ਕਰਦੀ ਹੈ, ਤਾਂ ਇਹ ਬਤਖ਼ ਹੀ ਹੋਵੇਗੀ।") Interfaces ਨੂੰ ਖਾਸ types ਨਾਲੋਂ ਵੱਧ ਮਹੱਤਵ ਦੇਣ ਕਰਕੇ, ਵਧੀਆ code polymorphic substitution ਦੀ ਆਗਿਆ ਦੇ ਕੇ ਵਧੇਰੇ ਲਚਕਤਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। Duck-typing type() ਜਾਂ isinstance() ਵਰਗੇ ਟੈਸਟਾਂ ਤੋਂ ਬਚਦੀ ਹੈ। ਹਾਲਾਂਕਿ, duck-typing ਨੂੰ abstract base classes ਨਾਲ ਪੂਰਾ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਦੀ ਬਜਾਏ ਇਹ ਆਮ ਤੌਰ 'ਤੇ hasattr() ਟੈਸਟਾਂ ਜਾਂ EAFP programming ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।

ਡੰਡਰ

"double underscore" ਲਈ ਇੱਕ ਗੈਰ-ਰਸਮੀ ਛੋਟਾ ਸ਼ਬਦ, ਜੋ special method ਬਾਰੇ ਗੱਲ ਕਰਦੇ ਸਮੇਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, __init__ ਨੂੰ ਅਕਸਰ "dunder init" ਕਿਹਾ ਜਾਂਦਾ ਹੈ।

EAFP

ਇਜਾਜ਼ਤ ਮੰਗਣ ਨਾਲੋਂ ਮਾਫ਼ੀ ਮੰਗਣਾ ਆਸਾਨ ਹੈ। Python ਦੀ ਇਹ ਆਮ coding ਸ਼ੈਲੀ ਇਹ ਮੰਨਦੀ ਹੈ ਕਿ ਲੋੜੀਂਦੀਆਂ keys ਜਾਂ attributes ਮੌਜੂਦ ਹਨ ਅਤੇ ਜੇ ਇਹ ਧਾਰਣਾ ਗਲਤ ਸਾਬਤ ਹੋਵੇ ਤਾਂ exceptions ਨੂੰ ਸੰਭਾਲ ਲੈਂਦੀ ਹੈ। ਇਹ ਸਾਫ਼ ਅਤੇ ਤੇਜ਼ ਸ਼ੈਲੀ ਕਈ try ਅਤੇ except statements ਦੀ ਮੌਜੂਦਗੀ ਨਾਲ ਪਛਾਣੀ ਜਾਂਦੀ ਹੈ। ਇਹ ਤਕਨੀਕ C ਵਰਗੀਆਂ ਕਈ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਆਮ LBYL ਸ਼ੈਲੀ ਦੇ ਉਲਟ ਹੈ।

ਮੁਲਾਂਕਣ ਫੰਕਸ਼ਨ

ਇੱਕ ਫੰਕਸ਼ਨ ਜਿਸਨੂੰ ਕਿਸੇ ਆਬਜੈਕਟ ਦੇ lazily evaluated attribute ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਲਈ ਕਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਵੇਂ type statement ਨਾਲ ਬਣੇ type aliases ਦੀ value।

exhausted

An iterator that has produced all of its values is said to be exhausted. Further attempts to get the next value (for example, calls to next()) raise StopIteration (or StopAsyncIteration in the case of an asynchronous iterator).

ਐਕਸਪ੍ਰੈਸ਼ਨ

A piece of syntax which can be evaluated to some value. In other words, an expression is an accumulation of expression elements like literals, names, attribute access, operators or function calls which all return a value. Not all language constructs are expressions. There are also statements which cannot be used as expressions, such as while. Assignments are also statements, not expressions.

ਐਕਸਟੈਂਸ਼ਨ ਮੋਡੀਊਲ

C ਜਾਂ C++ ਵਿੱਚ ਲਿਖਿਆ ਮੋਡੀਊਲ, ਜੋ Python ਦੇ C API ਦੀ ਵਰਤੋਂ ਕਰਕੇ core ਅਤੇ user code ਨਾਲ ਸੰਚਾਰ ਕਰਦਾ ਹੈ।

f-string

f-strings

f ਜਾਂ F ਨਾਲ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲੇ string literals ਨੂੰ ਆਮ ਤੌਰ 'ਤੇ "f-strings" ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਜੋ formatted string literals ਦਾ ਸੰਖੇਪ ਰੂਪ ਹੈ। PEP 498 ਵੀ ਵੇਖੋ।

ਫਾਇਲ ਆਬਜੈਕਟ

ਇੱਕ ਆਬਜੈਕਟ ਜੋ ਕਿਸੇ ਅਧਾਰਭੂਤ ਸਰੋਤ ਲਈ file-oriented API (ਜਿਵੇਂ read() ਜਾਂ write() ਮੈਥਡ) ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਇਸਦੀ ਬਣਤਰ ਦੇ ਤਰੀਕੇ ਅਨੁਸਾਰ, file object ਅਸਲ ਡਿਸਕ ਉੱਤੇ ਮੌਜੂਦ ਫਾਇਲ ਜਾਂ ਕਿਸੇ ਹੋਰ storage ਜਾਂ communication device (ਉਦਾਹਰਨ ਵਜੋਂ standard input/output, in-memory buffers, sockets, pipes ਆਦਿ) ਤੱਕ ਪਹੁੰਚ ਮੁਹੱਈਆ ਕਰ ਸਕਦਾ ਹੈ। File objects ਨੂੰ file-like objects ਜਾਂ streams ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।

ਅਸਲ ਵਿੱਚ file objects ਦੀਆਂ ਤਿੰਨ ਸ਼੍ਰੇਣੀਆਂ ਹਨ: raw binary files, buffered binary files ਅਤੇ text files। ਇਨ੍ਹਾਂ ਦੇ interfaces io module ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਹਨ। File object ਬਣਾਉਣ ਦਾ ਮਿਆਰੀ ਤਰੀਕਾ open() function ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੈ।

ਫਾਇਲ-ਸਮਾਨ ਆਬਜੈਕਟ

file object ਦਾ ਸਮਾਨਾਰਥਕ ਸ਼ਬਦ।

ਫਾਇਲਸਿਸਟਮ ਐਨਕੋਡਿੰਗ ਅਤੇ ਗਲਤੀ ਹੈਂਡਲਰ

Python ਦੁਆਰਾ operating system ਤੋਂ bytes ਨੂੰ decode ਕਰਨ ਅਤੇ Unicode ਨੂੰ operating system ਲਈ encode ਕਰਨ ਵਾਸਤੇ ਵਰਤੀ ਜਾਣ ਵਾਲੀ encoding ਅਤੇ error handler।

ਫਾਇਲਸਿਸਟਮ ਐਨਕੋਡਿੰਗ ਨੂੰ 128 ਤੋਂ ਘੱਟ ਸਾਰੇ bytes ਨੂੰ ਸਫਲਤਾਪੂਰਵਕ decode ਕਰਨ ਦੀ ਗਾਰੰਟੀ ਦੇਣੀ ਚਾਹੀਦੀ ਹੈ। ਜੇ ਫਾਇਲਸਿਸਟਮ ਐਨਕੋਡਿੰਗ ਇਹ ਗਾਰੰਟੀ ਦੇਣ ਵਿੱਚ ਅਸਫਲ ਰਹਿੰਦੀ ਹੈ, ਤਾਂ API ਫੰਕਸ਼ਨ UnicodeError ਉਠਾ ਸਕਦੇ ਹਨ।

ਫਾਇਲਸਿਸਟਮ ਐਨਕੋਡਿੰਗ ਅਤੇ error handler ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ sys.getfilesystemencoding() ਅਤੇ sys.getfilesystemencodeerrors() ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

filesystem encoding and error handler ਨੂੰ Python ਸ਼ੁਰੂ ਹੋਣ ਸਮੇਂ PyConfig_Read() ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਸੰਰਚਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। PyConfig ਦੇ filesystem_encoding ਅਤੇ filesystem_errors ਮੈਂਬਰ ਵੇਖੋ।

locale encoding ਵੀ ਵੇਖੋ।

ਫਾਈਂਡਰ

ਇੱਕ ਆਬਜੈਕਟ ਜੋ import ਕੀਤੇ ਜਾ ਰਹੇ module ਲਈ loader ਲੱਭਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ।

ਫਾਈਂਡਰ ਦੀਆਂ ਦੋ ਕਿਸਮਾਂ ਹਨ: sys.meta_path ਨਾਲ ਵਰਤੇ ਜਾਣ ਵਾਲੇ meta path finders ਅਤੇ sys.path_hooks ਨਾਲ ਵਰਤੇ ਜਾਣ ਵਾਲੇ path entry finders।

ਹੋਰ ਵਿਸਥਾਰ ਲਈ Finders and loaders ਅਤੇ importlib ਵੇਖੋ।

ਫਲੋਰ ਡਿਵਿਜ਼ਨ

ਗਣਿਤਕ ਭਾਗ ਜਿਸ ਵਿੱਚ ਨਤੀਜੇ ਨੂੰ ਹੇਠਾਂ ਵਾਲੇ ਸਭ ਤੋਂ ਨੇੜਲੇ ਪੂਰਨ ਅੰਕ ਵੱਲ round ਕੀਤਾ ਜਾਂਦਾ ਹੈ। Floor division operator // ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, 11 // 4 ਦਾ ਨਤੀਜਾ 2 ਹੁੰਦਾ ਹੈ, ਜਦਕਿ float true division 2.75 ਦਿੰਦੀ ਹੈ। ਧਿਆਨ ਦਿਓ ਕਿ (-11) // 4 ਦਾ ਨਤੀਜਾ -3 ਹੈ ਕਿਉਂਕਿ -2.75 ਨੂੰ ਹੇਠਾਂ ਵੱਲ round ਕੀਤਾ ਜਾਂਦਾ ਹੈ। PEP 238 ਵੇਖੋ।

ਫ੍ਰੀ ਥ੍ਰੈਡਿੰਗ

ਇੱਕ threading ਮਾਡਲ ਜਿਸ ਵਿੱਚ ਇੱਕੋ interpreter ਦੇ ਅੰਦਰ ਕਈ threads ਇਕੱਠੇ Python bytecode ਚਲਾ ਸਕਦੀਆਂ ਹਨ। ਇਹ global interpreter lock ਦੇ ਉਲਟ ਹੈ, ਜੋ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਸਿਰਫ਼ ਇੱਕ thread ਨੂੰ Python bytecode ਚਲਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। PEP 703 ਵੇਖੋ।

ਫ੍ਰੀ-ਥ੍ਰੈਡਡ ਬਿਲਡ

CPython ਦਾ ਇੱਕ build ਜੋ free threading ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ ਅਤੇ ਜਿਸਨੂੰ compilation ਤੋਂ ਪਹਿਲਾਂ --disable-gil ਵਿਕਲਪ ਨਾਲ ਸੰਰਚਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

Python support for free threading ਵੇਖੋ।

ਫ੍ਰੀ ਵੇਰੀਏਬਲ

ਰਸਮੀ ਤੌਰ 'ਤੇ, language execution model ਅਨੁਸਾਰ, free variable ਉਹ ਵੇਰੀਏਬਲ ਹੈ ਜੋ ਕਿਸੇ namespace ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਪਰ ਉਸ namespace ਦਾ local variable ਨਹੀਂ ਹੁੰਦਾ। ਉਦਾਹਰਨ ਲਈ closure variable ਵੇਖੋ। ਵਿਹਾਰਕ ਤੌਰ 'ਤੇ, codeobject.co_freevars attribute ਦੇ ਨਾਮ ਕਾਰਨ ਇਹ ਸ਼ਬਦ ਕਈ ਵਾਰ closure variable ਦੇ ਸਮਾਨਾਰਥਕ ਵਜੋਂ ਵੀ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

ਫੰਕਸ਼ਨ

Statements ਦੀ ਇੱਕ ਲੜੀ ਜੋ caller ਨੂੰ ਕੋਈ value ਵਾਪਸ ਕਰਦੀ ਹੈ। ਇਸਨੂੰ ਜ਼ੀਰੋ ਜਾਂ ਵੱਧ arguments ਵੀ ਦਿੱਤੇ ਜਾ ਸਕਦੇ ਹਨ, ਜੋ body ਦੇ execution ਦੌਰਾਨ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ। parameter, method, ਅਤੇ Function definitions ਭਾਗ ਵੀ ਵੇਖੋ।

ਫੰਕਸ਼ਨ ਐਨੋਟੇਸ਼ਨ

ਕਿਸੇ ਫੰਕਸ਼ਨ ਦੇ parameter ਜਾਂ return value ਦੀ annotation।

ਫੰਕਸ਼ਨ ਐਨੋਟੇਸ਼ਨ ਆਮ ਤੌਰ 'ਤੇ type hints ਲਈ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਉਦਾਹਰਨ ਵਜੋਂ, ਹੇਠਾਂ ਦਿੱਤਾ ਫੰਕਸ਼ਨ ਦੋ int arguments ਲੈਂਦਾ ਹੈ ਅਤੇ int return value ਦੇਣ ਦੀ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ:

def sum_two_numbers(a: int, b: int) -> int:
   return a + b

ਫੰਕਸ਼ਨ ਐਨੋਟੇਸ਼ਨ ਦਾ syntax Function definitions ਭਾਗ ਵਿੱਚ ਸਮਝਾਇਆ ਗਿਆ ਹੈ।

ਇਸ ਕਾਰਜਕੁਸ਼ਲਤਾ ਬਾਰੇ ਜਾਣਕਾਰੀ ਲਈ variable annotation ਅਤੇ PEP 484 ਵੇਖੋ। ਐਨੋਟੇਸ਼ਨਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀਆਂ ਵਧੀਆ ਪ੍ਰਥਾਵਾਂ ਲਈ Annotations Best Practices ਵੀ ਵੇਖੋ।

__future__

ਇੱਕ future statement, from __future__ import <feature>, compiler ਨੂੰ ਮੌਜੂਦਾ module ਨੂੰ ਉਸ syntax ਜਾਂ semantics ਨਾਲ compile ਕਰਨ ਲਈ ਨਿਰਦੇਸ਼ ਦਿੰਦਾ ਹੈ ਜੋ Python ਦੇ ਭਵਿੱਖਲੇ ਸੰਸਕਰਣ ਵਿੱਚ ਮਿਆਰੀ ਬਣੇਗਾ। __future__ module feature ਦੀਆਂ ਸੰਭਾਵਿਤ values ਦਾ ਵੇਰਵਾ ਦਿੰਦਾ ਹੈ। ਇਸ module ਨੂੰ import ਕਰਕੇ ਅਤੇ ਇਸਦੇ variables ਦਾ ਮੁਲਾਂਕਣ ਕਰਕੇ ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ ਕਿ ਕੋਈ ਨਵੀਂ ਵਿਸ਼ੇਸ਼ਤਾ ਭਾਸ਼ਾ ਵਿੱਚ ਪਹਿਲੀ ਵਾਰ ਕਦੋਂ ਜੋੜੀ ਗਈ ਸੀ ਅਤੇ ਕਦੋਂ ਇਹ default ਬਣੀ ਜਾਂ ਬਣੇਗੀ:

>>> import __future__
>>> __future__.division
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

ਗਾਰਬੇਜ ਕਲੇਕਸ਼ਨ

ਜਦੋਂ ਮੈਮੋਰੀ ਦੀ ਲੋੜ ਨਹੀਂ ਰਹਿੰਦੀ ਤਾਂ ਉਸਨੂੰ ਮੁਕਤ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ। Python reference counting ਅਤੇ cyclic garbage collector ਰਾਹੀਂ garbage collection ਕਰਦਾ ਹੈ, ਜੋ reference cycles ਨੂੰ ਖੋਜ ਅਤੇ ਤੋੜ ਸਕਦਾ ਹੈ। Garbage collector ਨੂੰ gc module ਦੀ ਮਦਦ ਨਾਲ ਨਿਯੰਤਰਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਜਨਰੇਟਰ

ਸੰਦਰਭ ਅਨੁਸਾਰ ਗੈਰ-ਆਧਿਕਾਰਿਕ ਤੌਰ 'ਤੇ ਇਸਦਾ ਅਰਥ ਜਾਂ ਤਾਂ generator function ਜਾਂ generator iterator ਹੁੰਦਾ ਹੈ। ਰਸਮੀ ਸ਼ਬਦ generator function ਅਤੇ generator iterator ਅਮਲ ਵਿੱਚ ਘੱਟ ਵਰਤੇ ਜਾਂਦੇ ਹਨ; ਕੇਵਲ "generator" ਕਹਿਣਾ ਲਗਭਗ ਹਰ ਵੇਲੇ ਕਾਫ਼ੀ ਹੁੰਦਾ ਹੈ।

ਜਨਰੇਟਰ ਫੰਕਸ਼ਨ

ਇੱਕ ਫੰਕਸ਼ਨ ਜੋ generator ਆਬਜੈਕਟ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਹ ਇੱਕ ਆਮ ਫੰਕਸ਼ਨ ਵਾਂਗ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ, ਪਰ ਇਸ ਵਿੱਚ yield ਐਕਸਪ੍ਰੈਸ਼ਨ ਹੁੰਦੀਆਂ ਹਨ ਜੋ for ਲੂਪ ਵਿੱਚ ਵਰਤੀ ਜਾ ਸਕਣ ਵਾਲੀਆਂ ਮੁੱਲਾਂ ਦੀ ਲੜੀ ਪੈਦਾ ਕਰਦੀਆਂ ਹਨ ਜਾਂ ਜਿਨ੍ਹਾਂ ਨੂੰ next() ਫੰਕਸ਼ਨ ਰਾਹੀਂ ਇੱਕ ਸਮੇਂ ਇੱਕ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਵੇਖੋ Yield expressions।

ਜਨਰੇਟਰ ਇਟਰੇਟਰ

generator function ਜਾਂ generator expression ਦੁਆਰਾ ਬਣਾਇਆ ਗਿਆ ਇੱਕ ਆਬਜੈਕਟ।

ਹਰ yield ਅਸਥਾਈ ਤੌਰ 'ਤੇ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਰੋਕ ਦਿੰਦਾ ਹੈ ਅਤੇ ਕਾਰਜਨਵਿਨ ਅਵਸਥਾ (ਸਥਾਨਕ ਵੇਰੀਏਬਲਾਂ ਅਤੇ ਬਕਾਇਆ try-statements ਸਮੇਤ) ਨੂੰ ਯਾਦ ਰੱਖਦਾ ਹੈ। ਜਦੋਂ generator iterator ਮੁੜ ਚਾਲੂ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਇਹ ਓਥੋਂ ਹੀ ਜਾਰੀ ਰਹਿੰਦਾ ਹੈ ਜਿੱਥੇ ਇਹ ਰੁਕਿਆ ਸੀ (ਉਨ੍ਹਾਂ ਫੰਕਸ਼ਨਾਂ ਦੇ ਉਲਟ ਜੋ ਹਰ ਵਾਰ ਨਵੇਂ ਸਿਰੇ ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ)।

Generator iterators send() ਮੈਥਡ ਵੀ ਲਾਗੂ ਕਰਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਰੁਕੇ ਹੋਏ generator ਨੂੰ ਕੋਈ ਮੁੱਲ ਭੇਜਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ throw() ਮੈਥਡ ਵੀ, ਜਿਸ ਨਾਲ ਉਸ ਬਿੰਦੂ 'ਤੇ exception ਉਠਾਈ ਜਾ ਸਕਦੀ ਹੈ ਜਿੱਥੇ generator ਰੁਕਿਆ ਹੋਇਆ ਸੀ। ਵੇਖੋ Generator iterators।

ਜਨਰੇਟਰ ਐਕਸਪ੍ਰੈਸ਼ਨ

ਇੱਕ expression ਜੋ iterator ਵਾਪਸ ਕਰਦੀ ਹੈ। ਇਹ ਇੱਕ ਆਮ expression ਵਾਂਗ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ ਜਿਸ ਤੋਂ ਬਾਅਦ loop variable, range ਅਤੇ ਇੱਕ ਵਿਕਲਪਿਕ if clause ਵਾਲੀ for clause ਹੁੰਦੀ ਹੈ। ਇਹ ਮਿਲੀ-ਜੁਲੀ expression enclosing function ਲਈ values ਤਿਆਰ ਕਰਦੀ ਹੈ:

>>> sum(i*i for i in range(10))         # sum of squares 0, 1, 4, ... 81
285

ਜੈਨੇਰਿਕ ਫੰਕਸ਼ਨ

ਇੱਕ ਫੰਕਸ਼ਨ ਜੋ ਕਈ ਫੰਕਸ਼ਨਾਂ ਤੋਂ ਬਣਿਆ ਹੁੰਦਾ ਹੈ ਅਤੇ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਲਈ ਇੱਕੋ ਕਾਰਵਾਈ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ। ਕਾਲ ਦੌਰਾਨ ਕਿਹੜਾ implementation ਵਰਤਣਾ ਹੈ, ਇਹ dispatch algorithm ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਇਹ ਵੀ ਵੇਖੋ: single dispatch ਸ਼ਬਦਾਵਲੀ ਐਂਟਰੀ, @functools.singledispatch ਸਜਾਵਟੀ ਫੰਕਸ਼ਨ, ਅਤੇ PEP 443।

ਜੈਨੇਰਿਕ ਕਿਸਮ

ਇੱਕ type ਜਿਸਨੂੰ parameterized ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ; ਆਮ ਤੌਰ 'ਤੇ list ਜਾਂ dict ਵਰਗੀ container class। ਇਸਦਾ ਉਪਯੋਗ type hints ਅਤੇ annotations ਲਈ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਹੋਰ ਵੇਰਵਿਆਂ ਲਈ generic alias types, PEP 483, PEP 484, PEP 585, ਅਤੇ typing module ਵੇਖੋ।

GIL

global interpreter lock ਵੇਖੋ।

ਗਲੋਬਲ ਇੰਟਰਪ੍ਰੀਟਰ ਲੌਕ

CPython interpreter ਦੁਆਰਾ ਵਰਤੀ ਜਾਣ ਵਾਲੀ ਵਿਧੀ ਜੋ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਕੇਵਲ ਇੱਕ thread ਹੀ Python bytecode ਚਲਾ ਸਕੇ। ਇਹ object model (ਜਿਸ ਵਿੱਚ dict ਵਰਗੀਆਂ ਮਹੱਤਵਪੂਰਨ built-in ਕਿਸਮਾਂ ਸ਼ਾਮਲ ਹਨ) ਨੂੰ concurrent access ਤੋਂ ਸੁਰੱਖਿਅਤ ਬਣਾਕੇ CPython implementation ਨੂੰ ਸੌਖਾ ਕਰਦੀ ਹੈ। ਪੂਰੇ interpreter ਨੂੰ lock ਕਰਨਾ multi-threading ਨੂੰ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ, ਪਰ ਇਸ ਨਾਲ multi-processor ਮਸ਼ੀਨਾਂ ਦੁਆਰਾ ਮਿਲਣ ਵਾਲੀ parallelism ਘੱਟ ਹੋ ਜਾਂਦੀ ਹੈ।

ਹਾਲਾਂਕਿ, ਕੁਝ standard ਜਾਂ third-party extension modules ਇਸ ਤਰ੍ਹਾਂ ਡਿਜ਼ਾਇਨ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਕਿ compression ਜਾਂ hashing ਵਰਗੇ computationally intensive ਕੰਮ ਕਰਦੇ ਸਮੇਂ GIL ਨੂੰ release ਕਰ ਦਿੰਦੇ ਹਨ। ਇਸ ਤੋਂ ਇਲਾਵਾ, I/O ਕਾਰਵਾਈਆਂ ਦੌਰਾਨ ਵੀ GIL ਹਮੇਸ਼ਾਂ release ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

Python 3.13 ਤੋਂ, GIL ਨੂੰ --disable-gil build configuration ਦੀ ਮਦਦ ਨਾਲ ਅਯੋਗ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਵਿਕਲਪ ਨਾਲ Python build ਕਰਨ ਤੋਂ ਬਾਅਦ, code ਨੂੰ -X gil=0 ਨਾਲ ਜਾਂ PYTHON_GIL=0 environment variable ਸੈੱਟ ਕਰਨ ਤੋਂ ਬਾਅਦ ਚਲਾਉਣਾ ਲਾਜ਼ਮੀ ਹੈ। ਇਹ ਵਿਸ਼ੇਸ਼ਤਾ multi-threaded applications ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਸੁਧਾਰਦੀ ਹੈ ਅਤੇ multi-core CPUs ਦਾ ਕੁਸ਼ਲਤਾਪੂਰਵਕ ਉਪਯੋਗ ਕਰਨਾ ਆਸਾਨ ਬਣਾਉਂਦੀ ਹੈ। ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ PEP 703 ਵੇਖੋ।

Python ਦੇ C API ਦੇ ਪੁਰਾਣੇ ਸੰਸਕਰਣਾਂ ਵਿੱਚ, ਕੋਈ ਫੰਕਸ਼ਨ ਇਹ ਘੋਸ਼ਿਤ ਕਰ ਸਕਦਾ ਸੀ ਕਿ ਉਸਨੂੰ ਵਰਤਣ ਲਈ GIL ਦਾ hold ਹੋਣਾ ਲਾਜ਼ਮੀ ਹੈ। ਇਹ attached thread state ਹੋਣ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।

ਗਲੋਬਲ ਸਟੇਟ

ਉਹ ਡਾਟਾ ਜੋ ਪੂਰੇ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਉਪਲਬਧ ਹੁੰਦਾ ਹੈ, ਜਿਵੇਂ module-level variables, class variables ਜਾਂ extension modules ਵਿੱਚ C static variables। Multi-threaded ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ threads ਵਿਚਕਾਰ ਸਾਂਝੀ ਕੀਤੀ ਗਈ global state ਲਈ ਆਮ ਤੌਰ 'ਤੇ synchronization ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਤਾਂ ਜੋ race conditions ਅਤੇ data races ਤੋਂ ਬਚਿਆ ਜਾ ਸਕੇ।

ਹੈਸ਼-ਅਧਾਰਿਤ pyc

ਇੱਕ bytecode cache ਫਾਈਲ ਜੋ ਆਪਣੀ ਵੈਧਤਾ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਸੰਬੰਧਿਤ source ਫਾਈਲ ਦੇ last-modified time ਦੀ ਬਜਾਏ hash ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ। Cached bytecode invalidation ਵੇਖੋ।

ਹੈਸ਼ਯੋਗ

ਕੋਈ object hashable ਹੁੰਦਾ ਹੈ ਜੇ ਇਸਦਾ hash value ਇਸਦੀ lifetime ਦੌਰਾਨ ਕਦੇ ਨਾ ਬਦਲੇ (ਇਸ ਲਈ __hash__() method ਲੋੜੀਂਦੀ ਹੈ), ਅਤੇ ਇਸਦੀ ਹੋਰ objects ਨਾਲ ਤੁਲਨਾ ਕੀਤੀ ਜਾ ਸਕੇ (ਇਸ ਲਈ __eq__() method ਲੋੜੀਂਦੀ ਹੈ)। ਜਿਹੜੇ hashable objects ਇੱਕੋ ਜਿਹੇ ਮੰਨੇ ਜਾਂਦੇ ਹਨ, ਉਨ੍ਹਾਂ ਦਾ hash value ਵੀ ਇੱਕੋ ਹੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

Hashability ਕਿਸੇ object ਨੂੰ dictionary key ਅਤੇ set member ਵਜੋਂ ਵਰਤਣਯੋਗ ਬਣਾਉਂਦੀ ਹੈ, ਕਿਉਂਕਿ ਇਹ data structures ਅੰਦਰੂਨੀ ਤੌਰ 'ਤੇ hash value ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ।

Python ਦੇ ਜ਼ਿਆਦਾਤਰ immutable built-in objects hashable ਹੁੰਦੇ ਹਨ; mutable containers (ਜਿਵੇਂ lists ਜਾਂ dictionaries) ਨਹੀਂ ਹੁੰਦੇ। Immutable containers (ਜਿਵੇਂ tuples ਅਤੇ frozensets) ਤਦੋਂ ਹੀ hashable ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਉਨ੍ਹਾਂ ਦੇ elements ਵੀ hashable ਹੋਣ। User-defined classes ਦੇ instances ਮੂਲ ਰੂਪ ਵਿੱਚ hashable ਹੁੰਦੇ ਹਨ। ਉਹ ਸਭ ਇੱਕ-ਦੂਜੇ ਤੋਂ ਅਸਮਾਨ ਮੰਨੇ ਜਾਂਦੇ ਹਨ (ਆਪਣੇ ਆਪ ਤੋਂ ਇਲਾਵਾ), ਅਤੇ ਉਨ੍ਹਾਂ ਦਾ hash value id() ਤੋਂ ਪ੍ਰਾਪਤ ਹੁੰਦਾ ਹੈ।

IDLE

Python ਲਈ ਇੱਕ Integrated Development and Learning Environment। IDLE --- Python editor and shell ਇੱਕ ਬੁਨਿਆਦੀ editor ਅਤੇ interpreter environment ਹੈ ਜੋ Python ਦੀ standard distribution ਨਾਲ ਮਿਲਦਾ ਹੈ।

ਅਮਰ

Immortal objects CPython implementation ਦਾ ਇੱਕ ਵੇਰਵਾ ਹਨ ਜੋ PEP 683 ਵਿੱਚ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ ਸੀ।

ਜੇ ਕੋਈ object immortal ਹੈ, ਤਾਂ ਉਸਦਾ reference count ਕਦੇ ਵੀ ਬਦਲਿਆ ਨਹੀਂ ਜਾਂਦਾ ਅਤੇ ਇਸ ਲਈ interpreter ਚੱਲਣ ਦੌਰਾਨ ਉਹ ਕਦੇ deallocate ਨਹੀਂ ਹੁੰਦਾ। ਉਦਾਹਰਨ ਵਜੋਂ, True ਅਤੇ None CPython ਵਿੱਚ immortal ਹਨ।

Immortal objects ਦੀ ਪਛਾਣ sys._is_immortal() ਜਾਂ C API ਵਿੱਚ PyUnstable_IsImmortal() ਰਾਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

ਅਪਰਿਵਰਤਨਸ਼ੀਲ

ਇੱਕ ਐਸਾ object ਜਿਸਦੀ value ਸਥਿਰ ਰਹਿੰਦੀ ਹੈ। Immutable objects ਵਿੱਚ numbers, strings ਅਤੇ tuples ਸ਼ਾਮਲ ਹਨ। ਅਜਿਹੇ object ਨੂੰ ਬਦਲਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ। ਜੇ ਵੱਖਰੀ value ਸੰਭਾਲਣੀ ਹੋਵੇ ਤਾਂ ਨਵਾਂ object ਬਣਾਉਣਾ ਪੈਂਦਾ ਹੈ। ਇਹ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦੇ ਹਨ ਜਿੱਥੇ ਇੱਕ ਸਥਿਰ hash value ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਜਿਵੇਂ dictionary key ਵਜੋਂ। Immutable objects ਸਵਭਾਵਿਕ ਤੌਰ 'ਤੇ thread-safe ਹੁੰਦੇ ਹਨ ਕਿਉਂਕਿ ਬਣਨ ਤੋਂ ਬਾਅਦ ਉਨ੍ਹਾਂ ਦੀ state ਬਦਲੀ ਨਹੀਂ ਜਾ ਸਕਦੀ, ਜਿਸ ਨਾਲ ਗਲਤ synchronized concurrent modification ਦੀ ਚਿੰਤਾ ਨਹੀਂ ਰਹਿੰਦੀ।

ਇੰਪੋਰਟ ਪਾਥ

ਥਾਵਾਂ (ਜਾਂ path entries) ਦੀ ਇੱਕ ਸੂਚੀ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਮੋਡੀਊਲ ਲੱਭਣ ਲਈ path based finder ਖੋਜ ਕਰਦਾ ਹੈ। Import ਦੌਰਾਨ ਇਹ ਸੂਚੀ ਆਮ ਤੌਰ 'ਤੇ sys.path ਤੋਂ ਆਉਂਦੀ ਹੈ, ਪਰ subpackages ਲਈ ਇਹ parent package ਦੇ __path__ attribute ਤੋਂ ਵੀ ਆ ਸਕਦੀ ਹੈ।

ਇੰਪੋਰਟ ਕਰਨਾ

ਉਹ ਪ੍ਰਕਿਰਿਆ ਜਿਸ ਰਾਹੀਂ ਇੱਕ module ਵਿੱਚ ਮੌਜੂਦ Python code ਨੂੰ ਕਿਸੇ ਹੋਰ module ਦੇ Python code ਲਈ ਉਪਲਬਧ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ।

ਇੰਪੋਰਟਰ

ਇੱਕ object ਜੋ module ਨੂੰ ਲੱਭਦਾ ਵੀ ਹੈ ਅਤੇ load ਵੀ ਕਰਦਾ ਹੈ; ਅਰਥਾਤ finder ਅਤੇ loader ਦੋਵੇਂ object।

ਇੰਡੈਕਸ

ਇੱਕ ਸੰਖਿਆਤਮਕ value ਜੋ ਕਿਸੇ sequence ਵਿੱਚ element ਦੀ ਸਥਿਤੀ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ।

Python ਵਿੱਚ indexing 0 ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, things[0] , things ਦੇ ਪਹਿਲੇ element ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਅਤੇ things[1] ਦੂਜੇ element ਨੂੰ।

ਕੁਝ ਸੰਦਰਭਾਂ ਵਿੱਚ Python sequence ਦੇ ਅੰਤ ਤੋਂ ਗਿਣਤੀ ਕਰਨ ਲਈ negative indexes ਅਤੇ slices ਦੀ ਵਰਤੋਂ ਨਾਲ indexing ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

subscript ਵੀ ਵੇਖੋ।

ਇੰਟਰਐਕਟਿਵ

Python ਕੋਲ ਇੱਕ ਇੰਟਰਐਕਟਿਵ ਇੰਟਰਪ੍ਰੀਟਰ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ਇੰਟਰਪ੍ਰੀਟਰ ਪ੍ਰੋਂਪਟ 'ਤੇ ਬਿਆਨ ਅਤੇ ਅਭਿਵਿਆਕਤੀਆਂ ਦਾਖਲ ਕਰ ਸਕਦੇ ਹੋ, ਤੁਰੰਤ ਉਹਨਾਂ ਨੂੰ ਚਲਾ ਸਕਦੇ ਹੋ ਅਤੇ ਉਹਨਾਂ ਦੇ ਨਤੀਜੇ ਵੇਖ ਸਕਦੇ ਹੋ। ਬਿਨਾਂ ਕਿਸੇ ਆਰਗੂਮੈਂਟ ਦੇ python ਚਲਾਓ (ਸ਼ਾਇਦ ਤੁਸੀਂ ਇਸਨੂੰ ਆਪਣੇ ਕੰਪਿਊਟਰ ਦੇ ਮੁੱਖ ਮੈਨੂ ਤੋਂ ਚੁਣ ਕੇ)। ਇਹ ਨਵੇਂ ਵਿਚਾਰਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਜਾਂ ਮੋਡਿਊਲਾਂ ਅਤੇ ਪੈਕੇਜਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਦਾ ਬਹੁਤ ਹੀ ਸ਼ਕਤੀਸ਼ਾਲੀ ਤਰੀਕਾ ਹੈ (ਯਾਦ ਰੱਖੋ help(x))। ਇੰਟਰਐਕਟਿਵ ਮੋਡ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ, ਵੇਖੋ ਇੰਟਰਐਕਟਿਵ ਮੋਡ ।

ਇੰਟਰਪ੍ਰੇਟ ਕੀਤਾ ਹੋਇਆ

Python ਇੱਕ interpreted language ਹੈ, compiled language ਦੇ ਉਲਟ, ਹਾਲਾਂਕਿ bytecode compiler ਦੀ ਮੌਜੂਦਗੀ ਕਾਰਨ ਇਹ ਅੰਤਰ ਕੁਝ ਹੱਦ ਤੱਕ ਧੁੰਦਲਾ ਹੋ ਸਕਦਾ ਹੈ। ਇਸਦਾ ਅਰਥ ਹੈ ਕਿ source files ਨੂੰ executable ਬਣਾਏ ਬਿਨਾਂ ਸਿੱਧਾ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। Interpreted languages ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ compiled languages ਨਾਲੋਂ ਛੋਟਾ development/debug cycle ਹੁੰਦਾ ਹੈ, ਹਾਲਾਂਕਿ ਉਹਨਾਂ ਦੇ ਪ੍ਰੋਗਰਾਮ ਆਮ ਤੌਰ 'ਤੇ ਹੌਲੇ ਚੱਲਦੇ ਹਨ। interactive ਵੀ ਵੇਖੋ।

ਇੰਟਰਪ੍ਰੀਟਰ ਸ਼ਟਡਾਊਨ

ਜਦੋਂ Python interpreter ਨੂੰ ਬੰਦ ਕਰਨ ਲਈ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਇਹ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਪੜਾਅ ਵਿੱਚ ਦਾਖਲ ਹੁੰਦਾ ਹੈ ਜਿੱਥੇ ਇਹ ਹੌਲੀ-ਹੌਲੀ ਸਾਰੇ allocated resources ਜਿਵੇਂ modules ਅਤੇ ਹੋਰ ਮਹੱਤਵਪੂਰਨ internal structures ਨੂੰ release ਕਰਦਾ ਹੈ। ਇਹ garbage collector ਨੂੰ ਵੀ ਕਈ ਵਾਰ ਕਾਲ ਕਰਦਾ ਹੈ। ਇਸ ਕਾਰਨ user-defined destructors ਜਾਂ weakref callbacks ਵਿੱਚ code ਚੱਲ ਸਕਦਾ ਹੈ। Shutdown phase ਦੌਰਾਨ ਚੱਲਣ ਵਾਲਾ code ਵੱਖ-ਵੱਖ exceptions ਦਾ ਸਾਹਮਣਾ ਕਰ ਸਕਦਾ ਹੈ ਕਿਉਂਕਿ ਜਿਨ੍ਹਾਂ resources 'ਤੇ ਉਹ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਉਹ ਹੁਣ ਕੰਮ ਨਹੀਂ ਕਰ ਰਹੇ ਹੋ ਸਕਦੇ।

Interpreter shutdown ਦਾ ਮੁੱਖ ਕਾਰਨ ਇਹ ਹੁੰਦਾ ਹੈ ਕਿ __main__ module ਜਾਂ ਚੱਲ ਰਹੀ script ਆਪਣਾ execution ਪੂਰਾ ਕਰ ਚੁੱਕੀ ਹੁੰਦੀ ਹੈ।

ਇਟਰੇਬਲ

ਇੱਕ ਐਸਾ object ਜੋ ਆਪਣੇ members ਨੂੰ ਇੱਕ-ਇੱਕ ਕਰਕੇ ਵਾਪਸ ਕਰ ਸਕਦਾ ਹੈ। Iterables ਦੀਆਂ ਉਦਾਹਰਨਾਂ ਵਿੱਚ ਸਾਰੇ sequence types (ਜਿਵੇਂ list, str, ਅਤੇ tuple) ਅਤੇ ਕੁਝ non-sequence types ਜਿਵੇਂ dict, file objects, ਅਤੇ ਉਹ objects ਸ਼ਾਮਲ ਹਨ ਜਿਨ੍ਹਾਂ ਦੀਆਂ classes ਵਿੱਚ __iter__() method ਜਾਂ sequence semantics ਲਾਗੂ ਕਰਨ ਵਾਲੀ __getitem__() method ਪਰਿਭਾਸ਼ਿਤ ਹੋਵੇ।

Iterables ਨੂੰ for loop ਅਤੇ ਹੋਰ ਕਈ ਥਾਵਾਂ 'ਤੇ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜਿੱਥੇ sequence ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ (zip(), map(), ਆਦਿ)। ਜਦੋਂ ਕਿਸੇ iterable object ਨੂੰ built-in function iter() ਨੂੰ argument ਵਜੋਂ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਉਸ object ਲਈ iterator ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਹ iterator values ਦੇ ਸਮੂਹ 'ਤੇ ਇੱਕ ਵਾਰ iteration ਕਰਨ ਲਈ ਹੁੰਦਾ ਹੈ। Iterables ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਆਮ ਤੌਰ 'ਤੇ iter() ਨੂੰ ਖੁਦ call ਕਰਨ ਜਾਂ iterator objects ਨੂੰ ਸਿੱਧੇ ਸੰਭਾਲਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ। for statement ਇਹ ਕੰਮ ਆਪਣੇ ਆਪ ਕਰਦਾ ਹੈ ਅਤੇ loop ਦੌਰਾਨ iterator ਰੱਖਣ ਲਈ ਇੱਕ ਅਸਥਾਈ unnamed variable ਬਣਾਉਂਦਾ ਹੈ। iterator, sequence, ਅਤੇ generator ਵੀ ਵੇਖੋ।

ਇਟਰੇਟਰ

An object representing a stream of data. Repeated calls to the iterator's __next__() method (or passing it to the built-in function next()) return successive items in the stream. When no more data are available a StopIteration exception is raised instead. At this point, the iterator object is exhausted and any further calls to its __next__() method just raise StopIteration again. Iterators are required to have an __iter__() method that returns the iterator object itself so every iterator is also iterable and may be used in most places where other iterables are accepted. One notable exception is code which attempts multiple iteration passes. A container object (such as a list) produces a fresh new iterator each time you pass it to the iter() function or use it in a for loop. Attempting this with an iterator will just return the same exhausted iterator object used in the previous iteration pass, making it appear like an empty container.

ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ Iteration-related types ਵੇਖੋ।

CPython ਹਮੇਸ਼ਾਂ ਇਸ ਲੋੜ ਨੂੰ ਸਖ਼ਤੀ ਨਾਲ ਲਾਗੂ ਨਹੀਂ ਕਰਦਾ ਕਿ iterator ਵਿੱਚ __iter__() method ਹੋਵੇ। ਇਹ ਵੀ ਧਿਆਨ ਰੱਖੋ ਕਿ free-threaded CPython iterator operations ਲਈ thread-safe ਵਿਹਾਰ ਦੀ ਗਾਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ।

ਕੀ

ਇੱਕ value ਜੋ mapping ਵਿੱਚ ਕਿਸੇ entry ਦੀ ਪਛਾਣ ਕਰਦੀ ਹੈ। subscript ਵੀ ਵੇਖੋ।

ਕੀ ਫੰਕਸ਼ਨ

Key function ਜਾਂ collation function ਇੱਕ callable ਹੁੰਦਾ ਹੈ ਜੋ sorting ਜਾਂ ordering ਲਈ ਵਰਤੀ ਜਾਣ ਵਾਲੀ value ਵਾਪਸ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, locale.strxfrm() locale-ਵਿਸ਼ੇਸ਼ sorting conventions ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ sort key ਤਿਆਰ ਕਰਦਾ ਹੈ।

Python ਦੇ ਕਈ tools elements ਦੀ ordering ਜਾਂ grouping ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ key functions ਸਵੀਕਾਰ ਕਰਦੇ ਹਨ। ਇਨ੍ਹਾਂ ਵਿੱਚ min(), max(), sorted(), list.sort(), heapq.merge(), heapq.nsmallest(), heapq.nlargest(), ਅਤੇ itertools.groupby() ਸ਼ਾਮਲ ਹਨ।

Key function ਬਣਾਉਣ ਦੇ ਕਈ ਤਰੀਕੇ ਹਨ। ਉਦਾਹਰਨ ਵਜੋਂ, str.casefold() method case-insensitive sorting ਲਈ key function ਵਜੋਂ ਕੰਮ ਕਰ ਸਕਦੀ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, lambda r: (r[0], r[2]) ਵਰਗੇ lambda expression ਨਾਲ ਵੀ key function ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। operator.attrgetter(), operator.itemgetter(), ਅਤੇ operator.methodcaller() ਤਿੰਨ key function constructors ਹਨ। Key functions ਬਣਾਉਣ ਅਤੇ ਵਰਤਣ ਦੀਆਂ ਉਦਾਹਰਨਾਂ ਲਈ Sorting HOW TO ਵੇਖੋ।

ਕੀਵਰਡ ਆਰਗਿਊਮੈਂਟ

argument ਵੇਖੋ।

ਲੈਂਬਡਾ

ਇੱਕ anonymous inline function ਜੋ ਇੱਕ ਹੀ expression ਤੋਂ ਬਣਿਆ ਹੁੰਦਾ ਹੈ ਅਤੇ function call ਹੋਣ 'ਤੇ evaluate ਕੀਤਾ ਜਾਂਦਾ ਹੈ। Lambda function ਬਣਾਉਣ ਦਾ syntax ਹੈ lambda [parameters]: expression

LBYL

Look before you leap. ਇਹ coding style calls ਜਾਂ lookups ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ pre-conditions ਦੀ ਜਾਂਚ ਕਰਦੀ ਹੈ। ਇਹ ਸ਼ੈਲੀ EAFP approach ਦੇ ਉਲਟ ਹੈ ਅਤੇ ਇਸਦੀ ਵਿਸ਼ੇਸ਼ਤਾ ਬਹੁਤ ਸਾਰੇ if statements ਹਨ।

Multi-threaded environment ਵਿੱਚ LBYL approach, "ਦੇਖਣ" ਅਤੇ "ਕਰਵਾਈ ਕਰਨ" ਦੇ ਵਿਚਕਾਰ race condition ਪੈਦਾ ਕਰਨ ਦਾ ਜੋਖਮ ਰੱਖਦੀ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, if key in mapping: return mapping[key] ਫੇਲ੍ਹ ਹੋ ਸਕਦਾ ਹੈ ਜੇਕਰ test ਤੋਂ ਬਾਅਦ ਪਰ lookup ਤੋਂ ਪਹਿਲਾਂ ਕੋਈ ਹੋਰ thread key ਨੂੰ mapping ਤੋਂ ਹਟਾ ਦੇਵੇ। ਇਸ ਸਮੱਸਿਆ ਨੂੰ locks ਜਾਂ EAFP approach ਨਾਲ ਹੱਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। thread-safe ਵੀ ਵੇਖੋ।

ਲੈਕਸੀਕਲ ਐਨਾਲਾਈਜ਼ਰ

tokenizer ਦਾ ਅਧਿਕਾਰਿਕ ਨਾਮ; token ਵੇਖੋ।

ਲਿਸਟ

A built-in Python sequence. Despite its name it is more akin to an array in other languages than to a linked list since access to elements is O(1). See Time complexity of operations on built-in types.

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

ਕਿਸੇ sequence ਦੇ ਸਾਰੇ ਜਾਂ ਕੁਝ elements ਨੂੰ process ਕਰਕੇ ਨਤੀਜਿਆਂ ਦੀ list ਵਾਪਸ ਕਰਨ ਦਾ ਇੱਕ ਸੰਖੇਪ ਤਰੀਕਾ। result = ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0] 0 ਤੋਂ 255 ਤੱਕ ਦੀ range ਵਿੱਚ even hexadecimal numbers (0x..) ਵਾਲੀਆਂ strings ਦੀ list ਬਣਾਉਂਦਾ ਹੈ। if clause ਵਿਕਲਪਿਕ ਹੈ। ਜੇ ਇਸਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾਵੇ ਤਾਂ range(256) ਦੇ ਸਾਰੇ elements process ਕੀਤੇ ਜਾਂਦੇ ਹਨ।

ਲਾਕ

ਇੱਕ synchronization primitive ਜੋ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਸਿਰਫ਼ ਇੱਕ thread ਨੂੰ shared resource ਤੱਕ ਪਹੁੰਚ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। Protected resource ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ thread ਨੂੰ lock acquire ਕਰਨਾ ਅਤੇ ਬਾਅਦ ਵਿੱਚ release ਕਰਨਾ ਲਾਜ਼ਮੀ ਹੈ। ਜੇ ਕੋਈ thread ਉਸ lock ਨੂੰ acquire ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੇ ਜੋ ਪਹਿਲਾਂ ਹੀ ਕਿਸੇ ਹੋਰ thread ਕੋਲ ਹੈ, ਤਾਂ ਉਹ lock ਉਪਲਬਧ ਹੋਣ ਤੱਕ ਰੁਕਿਆ ਰਹੇਗਾ। Python ਦਾ threading module Lock (basic lock) ਅਤੇ RLock (reentrant lock) ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। Locks ਦਾ ਉਪਯੋਗ race conditions ਤੋਂ ਬਚਾਅ ਅਤੇ shared data ਲਈ thread-safe access ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। Locks ਦੇ ਵਿਕਲਪ ਵਜੋਂ queues, producer/consumer patterns ਅਤੇ thread-local state ਵਰਗੇ design patterns ਵੀ ਮੌਜੂਦ ਹਨ। deadlock ਅਤੇ reentrant ਵੀ ਵੇਖੋ।

ਲਾਕ-ਫ੍ਰੀ

ਇੱਕ ਐਸੀ operation ਜੋ ਕੋਈ lock acquire ਨਹੀਂ ਕਰਦੀ ਅਤੇ correctness ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ atomic CPU instructions ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ। Lock-free operations ਇਕੱਠੇ ਚੱਲ ਸਕਦੀਆਂ ਹਨ ਬਿਨਾਂ ਇੱਕ-ਦੂਜੇ ਨੂੰ block ਕੀਤੇ ਅਤੇ ਉਹਨਾਂ ਨੂੰ lock ਰੱਖਣ ਵਾਲੀਆਂ operations ਦੁਆਰਾ ਵੀ block ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ। free-threaded Python ਵਿੱਚ dict ਅਤੇ list ਵਰਗੇ built-in types lock-free read operations ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਹੋਰ threads multi-step modifications ਦੌਰਾਨ intermediate states ਨੂੰ ਵੇਖ ਸਕਦੇ ਹਨ ਭਾਵੇਂ ਉਹ modifications per-object lock ਰੱਖ ਰਹੀਆਂ ਹੋਣ।

ਲੋਡਰ

ਇੱਕ object ਜੋ module ਨੂੰ load ਕਰਦਾ ਹੈ। ਇਸਨੂੰ Loader interface ਨੂੰ implement ਕਰਨ ਲਈ exec_module() ਅਤੇ create_module() methods ਪਰਿਭਾਸ਼ਿਤ ਕਰਨੀਆਂ ਲਾਜ਼ਮੀ ਹਨ। ਆਮ ਤੌਰ 'ਤੇ loader ਨੂੰ finder ਦੁਆਰਾ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਵੀ ਵੇਖੋ:

• Finders and loaders

• importlib.abc.Loader

• PEP 302

ਲੋਕੇਲ ਐਨਕੋਡਿੰਗ

Unix 'ਤੇ ਇਹ LC_CTYPE locale ਦੀ encoding ਹੁੰਦੀ ਹੈ। ਇਸਨੂੰ locale.setlocale(locale.LC_CTYPE, new_locale) ਨਾਲ ਸੈੱਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

Windows 'ਤੇ ਇਹ ANSI code page ਹੁੰਦਾ ਹੈ (ਉਦਾਹਰਨ: "cp1252")।

Android ਅਤੇ VxWorks 'ਤੇ Python "utf-8" ਨੂੰ locale encoding ਵਜੋਂ ਵਰਤਦਾ ਹੈ।

Locale encoding ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ locale.getencoding() ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ।

filesystem encoding and error handler ਵੀ ਵੇਖੋ।

ਮੈਜਿਕ ਮੈਥਡ

special method ਲਈ ਇੱਕ ਗੈਰ-ਆਧਿਕਾਰਿਕ ਸਮਾਨਾਰਥਕ ਸ਼ਬਦ।

ਮੈਪਿੰਗ

ਇੱਕ container object ਜੋ arbitrary key lookups ਨੂੰ support ਕਰਦਾ ਹੈ ਅਤੇ collections.abc.Mapping ਜਾਂ collections.abc.MutableMapping abstract base classes ਵਿੱਚ ਦਿੱਤੀਆਂ methods ਨੂੰ implement ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨਾਂ ਵਿੱਚ dict, collections.defaultdict, collections.OrderedDict ਅਤੇ collections.Counter ਸ਼ਾਮਲ ਹਨ।

ਮੈਟਾ ਪਾਥ ਫਾਈਂਡਰ

sys.meta_path ਦੀ ਖੋਜ ਤੋਂ ਵਾਪਸ ਮਿਲਣ ਵਾਲਾ ਇੱਕ finder। Meta path finders, path entry finders ਨਾਲ ਸੰਬੰਧਿਤ ਤਾਂ ਹਨ, ਪਰ ਉਹਨਾਂ ਤੋਂ ਵੱਖਰੇ ਹਨ।

Meta path finders ਦੁਆਰਾ implement ਕੀਤੀਆਂ methods ਲਈ importlib.abc.MetaPathFinder ਵੇਖੋ।

ਮੈਟਾਕਲਾਸ

ਕਲਾਸ ਦੀ ਕਲਾਸ। Class definitions ਇੱਕ class name, ਇੱਕ class dictionary ਅਤੇ base classes ਦੀ ਇੱਕ ਸੂਚੀ ਬਣਾਉਂਦੀਆਂ ਹਨ। Metaclass ਦੀ ਜ਼ਿੰਮੇਵਾਰੀ ਇਹਨਾਂ ਤਿੰਨਾਂ arguments ਨੂੰ ਲੈ ਕੇ class ਬਣਾਉਣ ਦੀ ਹੁੰਦੀ ਹੈ। ਜ਼ਿਆਦਾਤਰ object-oriented programming languages ਇੱਕ default implementation ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ। Python ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ ਇਹ ਹੈ ਕਿ custom metaclasses ਬਣਾਈਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ। ਬਹੁਤੇ users ਨੂੰ ਇਸਦੀ ਲੋੜ ਨਹੀਂ ਪੈਂਦੀ, ਪਰ ਜਦੋਂ ਲੋੜ ਪੈਂਦੀ ਹੈ ਤਾਂ metaclasses ਸ਼ਕਤੀਸ਼ਾਲੀ ਅਤੇ ਸੁੰਦਰ ਹੱਲ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦੀਆਂ ਹਨ। ਇਹਨਾਂ ਦਾ ਉਪਯੋਗ attribute access logging, thread-safety ਜੋੜਨ, object creation tracking, singleton implementation ਅਤੇ ਹੋਰ ਕਈ ਕੰਮਾਂ ਲਈ ਕੀਤਾ ਗਿਆ ਹੈ।

ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ Metaclasses ਵੇਖੋ।

ਮੈਥਡ

ਇੱਕ function ਜੋ class body ਦੇ ਅੰਦਰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਜੇ ਇਸਨੂੰ ਉਸ class ਦੇ ਕਿਸੇ instance ਦੇ attribute ਵਜੋਂ call ਕੀਤਾ ਜਾਵੇ, ਤਾਂ method ਨੂੰ instance object ਆਪਣਾ ਪਹਿਲਾ argument ਮਿਲਦਾ ਹੈ (ਜਿਸਨੂੰ ਆਮ ਤੌਰ 'ਤੇ self ਕਿਹਾ ਜਾਂਦਾ ਹੈ)। function ਅਤੇ nested scope ਵੀ ਵੇਖੋ।

ਮੈਥਡ ਰੈਜ਼ੋਲਿਊਸ਼ਨ ਆਰਡਰ

Method Resolution Order ਉਹ ਕ੍ਰਮ ਹੈ ਜਿਸ ਵਿੱਚ lookup ਦੌਰਾਨ member ਲਈ base classes ਦੀ ਖੋਜ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। Python interpreter ਦੁਆਰਾ version 2.3 ਤੋਂ ਵਰਤੇ ਜਾ ਰਹੇ algorithm ਦੇ ਵੇਰਵਿਆਂ ਲਈ The Python 2.3 Method Resolution Order ਵੇਖੋ।

ਮੋਡੀਊਲ

ਇੱਕ object ਜੋ Python code ਦੀ ਸੰਗਠਨਾਤਮਕ ਇਕਾਈ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ। Modules ਕੋਲ ਇੱਕ namespace ਹੁੰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ arbitrary Python objects ਹੋ ਸਕਦੇ ਹਨ। Modules ਨੂੰ importing ਦੀ ਪ੍ਰਕਿਰਿਆ ਰਾਹੀਂ Python ਵਿੱਚ load ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

package ਵੀ ਵੇਖੋ।

ਮੋਡੀਊਲ ਸਪੈਕ

ਇੱਕ namespace ਜਿਸ ਵਿੱਚ module ਨੂੰ load ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਣ ਵਾਲੀ import-ਸੰਬੰਧੀ ਜਾਣਕਾਰੀ ਹੁੰਦੀ ਹੈ। ਇਹ importlib.machinery.ModuleSpec ਦਾ ਇੱਕ instance ਹੁੰਦਾ ਹੈ।

Module specs ਵੀ ਵੇਖੋ।

MRO

method resolution order ਵੇਖੋ।

ਬਦਲਣਯੋਗ

ਇੱਕ object ਜਿਸਦੀ state ਪ੍ਰੋਗਰਾਮ ਦੇ ਚੱਲਣ ਦੌਰਾਨ ਬਦਲ ਸਕਦੀ ਹੈ। Multi-threaded programs ਵਿੱਚ threads ਵਿਚਕਾਰ ਸਾਂਝੇ mutable objects ਲਈ race conditions ਤੋਂ ਬਚਣ ਵਾਸਤੇ ਧਿਆਨਪੂਰਵਕ synchronization ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। immutable, thread-safe, ਅਤੇ concurrent modification ਵੀ ਵੇਖੋ।

ਨੇਮਡ ਟਿਊਪਲ

"Named tuple" ਸ਼ਬਦ ਕਿਸੇ ਵੀ ਐਸੀ type ਜਾਂ class ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜੋ tuple ਤੋਂ inherit ਕਰਦੀ ਹੋਵੇ ਅਤੇ ਜਿਸਦੇ indexable elements ਨੂੰ named attributes ਰਾਹੀਂ ਵੀ access ਕੀਤਾ ਜਾ ਸਕੇ। ਉਸ type ਜਾਂ class ਵਿੱਚ ਹੋਰ features ਵੀ ਹੋ ਸਕਦੇ ਹਨ।

ਕਈ built-in types named tuples ਹਨ, ਜਿਨ੍ਹਾਂ ਵਿੱਚ time.localtime() ਅਤੇ os.stat() ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੀਆਂ values ਸ਼ਾਮਲ ਹਨ। ਇੱਕ ਹੋਰ ਉਦਾਹਰਨ sys.float_info ਹੈ:

>>> sys.float_info[1]                   # indexed access
1024
>>> sys.float_info.max_exp              # named field access
1024
>>> isinstance(sys.float_info, tuple)   # kind of tuple
True

ਕੁਝ named tuples built-in types ਹੁੰਦੇ ਹਨ (ਜਿਵੇਂ ਉੱਪਰ ਦਿੱਤੀਆਂ ਉਦਾਹਰਨਾਂ)। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇੱਕ named tuple ਨੂੰ ਐਸੀ ਆਮ class definition ਤੋਂ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਜੋ tuple ਤੋਂ inherit ਕਰਦੀ ਹੋਵੇ ਅਤੇ named fields ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀ ਹੋਵੇ। ਐਸੀ class ਨੂੰ ਹੱਥੋਂ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਜਾਂ typing.NamedTuple ਤੋਂ inherit ਕਰਕੇ ਜਾਂ collections.namedtuple() factory function ਨਾਲ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ ਆਖ਼ਰੀ ਤਰੀਕੇ ਕੁਝ ਵਾਧੂ methods ਵੀ ਜੋੜਦੇ ਹਨ ਜੋ ਹੱਥੋਂ ਲਿਖੇ ਜਾਂ built-in named tuples ਵਿੱਚ ਨਹੀਂ ਮਿਲ ਸਕਦੇ।

ਨੇਮਸਪੇਸ

ਉਹ ਥਾਂ ਜਿੱਥੇ ਕੋਈ variable ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ। Namespaces ਨੂੰ dictionaries ਵਜੋਂ implement ਕੀਤਾ ਜਾਂਦਾ ਹੈ। Local, global ਅਤੇ built-in namespaces ਤੋਂ ਇਲਾਵਾ objects (methods ਵਿੱਚ) nested namespaces ਵੀ ਹੁੰਦੇ ਹਨ। Namespaces ਨਾਮਾਂ ਦੇ ਟਕਰਾਅ ਨੂੰ ਰੋਕ ਕੇ modularity ਨੂੰ ਸਮਰਥਨ ਦਿੰਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ, builtins.open ਅਤੇ os.open() functions ਆਪਣੇ namespaces ਰਾਹੀਂ ਵੱਖ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। Namespaces readability ਅਤੇ maintainability ਵਿੱਚ ਵੀ ਮਦਦ ਕਰਦੇ ਹਨ ਕਿਉਂਕਿ ਇਹ ਸਪਸ਼ਟ ਕਰਦੇ ਹਨ ਕਿ ਕੋਈ function ਕਿਸ module ਦੁਆਰਾ implement ਕੀਤੀ ਗਈ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, random.seed() ਜਾਂ itertools.islice() ਲਿਖਣ ਨਾਲ ਸਪਸ਼ਟ ਹੁੰਦਾ ਹੈ ਕਿ ਇਹ functions ਕ੍ਰਮਵਾਰ random ਅਤੇ itertools modules ਦੁਆਰਾ implement ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ।

ਨੇਮਸਪੇਸ ਪੈਕੇਜ

ਇੱਕ package ਜੋ ਸਿਰਫ਼ subpackages ਲਈ container ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ। Namespace packages ਦੀ ਕੋਈ physical representation ਨਹੀਂ ਵੀ ਹੋ ਸਕਦੀ, ਅਤੇ ਇਹ regular package ਵਰਗੇ ਨਹੀਂ ਹੁੰਦੇ ਕਿਉਂਕਿ ਇਨ੍ਹਾਂ ਵਿੱਚ __init__.py ਫਾਈਲ ਨਹੀਂ ਹੁੰਦੀ।

Namespace packages ਕਈ ਵੱਖ-ਵੱਖ install ਹੋਣ ਵਾਲੇ packages ਨੂੰ ਇੱਕ ਸਾਂਝਾ parent package ਰੱਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ। ਨਹੀਂ ਤਾਂ, regular package ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਸਿਫ਼ਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ PEP 420 ਅਤੇ Namespace packages ਵੇਖੋ।

module ਵੀ ਵੇਖੋ।

ਨੇਟਿਵ ਕੋਡ

ਉਹ code ਜੋ machine instructions ਵਿੱਚ compile ਹੁੰਦਾ ਹੈ ਅਤੇ processor ਉੱਤੇ ਸਿੱਧਾ ਚਲਦਾ ਹੈ, ਨਾ ਕਿ interpreted code ਜਾਂ virtual machine ਵਿੱਚ ਚੱਲਣ ਵਾਲਾ code। Python ਦੇ ਸੰਦਰਭ ਵਿੱਚ, native code ਆਮ ਤੌਰ 'ਤੇ extension modules ਵਿੱਚ ਮੌਜੂਦ C, C++, Rust ਜਾਂ Fortran code ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਜਿਸਨੂੰ Python ਤੋਂ call ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। extension module ਵੀ ਵੇਖੋ।

ਨੇਸਟਡ ਸਕੋਪ

ਕਿਸੇ enclosing definition ਵਿੱਚ ਮੌਜੂਦ variable ਨੂੰ ਸੰਬੋਧਨ ਕਰਨ ਦੀ ਸਮਰੱਥਾ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ function ਦੇ ਅੰਦਰ ਪਰਿਭਾਸ਼ਿਤ ਹੋਈ ਹੋਰ function ਬਾਹਰੀ function ਦੇ variables ਨੂੰ ਵਰਤ ਸਕਦੀ ਹੈ। ਧਿਆਨ ਰਹੇ ਕਿ nested scopes ਮੂਲ ਰੂਪ ਵਿੱਚ ਸਿਰਫ਼ reference ਲਈ ਕੰਮ ਕਰਦੀਆਂ ਹਨ, assignment ਲਈ ਨਹੀਂ। Local variables ਸਭ ਤੋਂ ਅੰਦਰਲੇ scope ਵਿੱਚ ਪੜ੍ਹੇ ਅਤੇ ਲਿਖੇ ਜਾਂਦੇ ਹਨ। ਇਸੇ ਤਰ੍ਹਾਂ global variables global namespace ਵਿੱਚ ਪੜ੍ਹੇ ਅਤੇ ਲਿਖੇ ਜਾਂਦੇ ਹਨ। nonlocal ਬਾਹਰੀ scopes ਵਿੱਚ ਲਿਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।

ਨਿਊ-ਸਟਾਈਲ ਕਲਾਸ

ਉਨ੍ਹਾਂ classes ਲਈ ਪੁਰਾਣਾ ਨਾਮ ਜੋ ਹੁਣ ਸਾਰੇ class objects ਲਈ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। Python ਦੇ ਪੁਰਾਣੇ versions ਵਿੱਚ ਸਿਰਫ਼ new-style classes ਹੀ Python ਦੀਆਂ ਨਵੀਆਂ ਅਤੇ ਲਚਕੀਲੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਜਿਵੇਂ __slots__, descriptors, properties, __getattribute__(), class methods ਅਤੇ static methods ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੀਆਂ ਸਨ।

ਗੈਰ-ਨਿਰਧਾਰਤ

ਐਸਾ ਵਿਹਾਰ ਜਿਸ ਵਿੱਚ ਇੱਕੋ inputs ਹੋਣ ਦੇ ਬਾਵਜੂਦ ਪ੍ਰੋਗਰਾਮ ਦਾ ਨਤੀਜਾ ਵੱਖ-ਵੱਖ executions ਵਿੱਚ ਬਦਲ ਸਕਦਾ ਹੈ। Multi-threaded programs ਵਿੱਚ non-deterministic behavior ਅਕਸਰ race conditions ਕਾਰਨ ਹੁੰਦਾ ਹੈ, ਜਿੱਥੇ threads ਦੀ timing ਜਾਂ interleaving ਨਤੀਜੇ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੀ ਹੈ। locks ਅਤੇ ਹੋਰ synchronization primitives ਦੀ ਸਹੀ ਵਰਤੋਂ deterministic behavior ਯਕੀਨੀ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ।

ਆਬਜੈਕਟ

ਕੋਈ ਵੀ data ਜਿਸਦੀ state (attributes ਜਾਂ value) ਅਤੇ ਪਰਿਭਾਸ਼ਿਤ behavior (methods) ਹੋਵੇ। ਇਹ ਕਿਸੇ ਵੀ new-style class ਦੀ ਅੰਤਿਮ base class ਵੀ ਹੈ।

ਆਪਟੀਮਾਈਜ਼ਡ ਸਕੋਪ

ਇੱਕ scope ਜਿਸ ਵਿੱਚ code compile ਹੋਣ ਸਮੇਂ target local variable names compiler ਨੂੰ ਭਰੋਸੇਯੋਗ ਤੌਰ 'ਤੇ ਪਤਾ ਹੁੰਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਇਨ੍ਹਾਂ names ਲਈ read ਅਤੇ write access ਨੂੰ optimize ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। Functions, generators, coroutines, comprehensions ਅਤੇ generator expressions ਦੇ local namespaces ਇਸ ਤਰੀਕੇ ਨਾਲ optimized ਹੁੰਦੇ ਹਨ। ਨੋਟ: interpreter ਦੀਆਂ ਜ਼ਿਆਦਾਤਰ optimizations ਸਾਰੇ scopes 'ਤੇ ਲਾਗੂ ਹੁੰਦੀਆਂ ਹਨ; ਸਿਰਫ਼ ਉਹ optimizations ਜੋ local ਅਤੇ nonlocal variable names ਦੇ ਜਾਣੇ-ਪਛਾਣੇ ਸਮੂਹ 'ਤੇ ਨਿਰਭਰ ਹੁੰਦੀਆਂ ਹਨ, optimized scopes ਤੱਕ ਸੀਮਿਤ ਰਹਿੰਦੀਆਂ ਹਨ।

ਵਿਕਲਪਿਕ ਮੋਡੀਊਲ

ਇੱਕ extension module ਜੋ standard library ਦਾ ਹਿੱਸਾ ਹੁੰਦਾ ਹੈ, ਪਰ CPython ਦੇ ਕੁਝ builds ਵਿੱਚ ਮੌਜੂਦ ਨਹੀਂ ਵੀ ਹੋ ਸਕਦਾ, ਆਮ ਤੌਰ 'ਤੇ third-party libraries ਦੀ ਗੈਰਮੌਜੂਦਗੀ ਜਾਂ ਕਿਸੇ ਖਾਸ platform ਲਈ module ਦੇ ਉਪਲਬਧ ਨਾ ਹੋਣ ਕਾਰਨ।

Third-party libraries ਦੀ ਲੋੜ ਵਾਲੇ optional modules ਦੀ ਸੂਚੀ ਲਈ ਵਿਕਲਪਿਕ ਮੋਡੀਊਲਾਂ ਲਈ ਲੋੜਾਂ ਵੇਖੋ।

ਪੈਕੇਜ

ਇੱਕ Python module ਜੋ submodules ਜਾਂ ਦੁਹਰਾਏ ਤੌਰ 'ਤੇ subpackages ਰੱਖ ਸਕਦਾ ਹੈ। ਤਕਨੀਕੀ ਤੌਰ 'ਤੇ, package ਇੱਕ Python module ਹੁੰਦਾ ਹੈ ਜਿਸਦੇ ਕੋਲ __path__ attribute ਹੁੰਦਾ ਹੈ।

regular package ਅਤੇ namespace package ਵੀ ਵੇਖੋ।

ਪੈਰਾਲਲਿਜ਼ਮ

ਇੱਕੋ ਸਮੇਂ ਕਈ operations ਚਲਾਉਣਾ (ਉਦਾਹਰਨ ਲਈ ਕਈ CPU cores ਉੱਤੇ)। global interpreter lock (GIL) ਵਾਲੀਆਂ Python builds ਵਿੱਚ ਇੱਕ ਸਮੇਂ ਸਿਰਫ਼ ਇੱਕ thread ਹੀ Python bytecode ਚਲਾ ਸਕਦਾ ਹੈ, ਇਸ ਲਈ ਕਈ CPU cores ਦਾ ਲਾਭ ਲੈਣ ਲਈ ਆਮ ਤੌਰ 'ਤੇ ਕਈ processes (ਜਿਵੇਂ multiprocessing) ਜਾਂ ਉਹ native extensions ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਜੋ GIL ਨੂੰ release ਕਰਦੀਆਂ ਹਨ। free-threaded Python ਵਿੱਚ ਕਈ Python threads ਵੱਖ-ਵੱਖ cores ਉੱਤੇ ਇੱਕੋ ਸਮੇਂ Python code ਚਲਾ ਸਕਦੀਆਂ ਹਨ।

ਪੈਰਾਮੀਟਰ

function (ਜਾਂ method) ਦੀ definition ਵਿੱਚ ਇੱਕ ਨਾਮਿਤ ਇਕਾਈ ਜੋ ਉਸ argument (ਜਾਂ ਕੁਝ ਮਾਮਲਿਆਂ ਵਿੱਚ arguments) ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ ਜੋ function ਸਵੀਕਾਰ ਕਰ ਸਕਦੀ ਹੈ। Parameter ਦੀਆਂ ਪੰਜ ਕਿਸਮਾਂ ਹੁੰਦੀਆਂ ਹਨ:

• positional-or-keyword: ਉਹ argument ਦਰਸਾਉਂਦਾ ਹੈ ਜੋ positionally ਜਾਂ keyword argument ਵਜੋਂ ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ parameter ਦੀ ਮੂਲ ਕਿਸਮ ਹੈ, ਉਦਾਹਰਨ ਲਈ ਹੇਠਾਂ ਦਿੱਤੇ foo ਅਤੇ bar:

  def func(foo, bar=None): ...
  

• positional-only: ਉਹ argument ਦਰਸਾਉਂਦਾ ਹੈ ਜੋ ਸਿਰਫ਼ position ਰਾਹੀਂ ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ। Positional-only parameters ਨੂੰ function definition ਦੀ parameter list ਵਿੱਚ ਉਨ੍ਹਾਂ ਤੋਂ ਬਾਅਦ / ਚਿੰਨ੍ਹ ਜੋੜ ਕੇ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ posonly1 ਅਤੇ posonly2:

  def func(posonly1, posonly2, /, positional_or_keyword): ...
  

• keyword-only: ਉਹ argument ਦਰਸਾਉਂਦਾ ਹੈ ਜੋ ਸਿਰਫ਼ keyword ਰਾਹੀਂ ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ। Keyword-only parameters ਨੂੰ function definition ਦੀ parameter list ਵਿੱਚ ਉਨ੍ਹਾਂ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ var-positional parameter ਜਾਂ ਖਾਲੀ * ਜੋੜ ਕੇ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ kw_only1 ਅਤੇ kw_only2:

  def func(arg, *, kw_only1, kw_only2): ...
  

• var-positional: ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ positional arguments ਦੀ ਮਨਚਾਹੀ ਲੜੀ ਦਿੱਤੀ ਜਾ ਸਕਦੀ ਹੈ (ਉਨ੍ਹਾਂ positional arguments ਤੋਂ ਇਲਾਵਾ ਜੋ ਹੋਰ parameters ਪਹਿਲਾਂ ਹੀ ਸਵੀਕਾਰ ਕਰਦੇ ਹਨ)। ਐਸਾ parameter ਉਸਦੇ ਨਾਮ ਤੋਂ ਪਹਿਲਾਂ * ਲਗਾ ਕੇ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ args:

  def func(*args, **kwargs): ...
  

• var-keyword: ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਮਨਚਾਹੀ ਗਿਣਤੀ ਦੇ keyword arguments ਦਿੱਤੇ ਜਾ ਸਕਦੇ ਹਨ (ਉਨ੍ਹਾਂ keyword arguments ਤੋਂ ਇਲਾਵਾ ਜੋ ਹੋਰ parameters ਪਹਿਲਾਂ ਹੀ ਸਵੀਕਾਰ ਕਰਦੇ ਹਨ)। ਐਸਾ parameter ਉਸਦੇ ਨਾਮ ਤੋਂ ਪਹਿਲਾਂ ** ਲਗਾ ਕੇ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਿਵੇਂ ਉੱਪਰਲੇ ਉਦਾਹਰਨ ਵਿੱਚ kwargs।

Parameters optional ਅਤੇ required ਦੋਵੇਂ ਕਿਸਮ ਦੇ arguments ਦਰਸਾ ਸਕਦੇ ਹਨ, ਅਤੇ ਕੁਝ optional arguments ਲਈ default values ਵੀ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹਨ।

argument glossary entry, the difference between arguments and parameters, inspect.Parameter class, Function definitions section ਅਤੇ PEP 362 ਵੀ ਵੇਖੋ।

ਪ੍ਰਤੀ-ਆਬਜੈਕਟ ਲਾਕ

ਇੱਕ lock ਜੋ ਸਾਰੇ objects ਵਿੱਚ ਸਾਂਝੇ global lock ਦੀ ਬਜਾਇ ਕਿਸੇ ਵਿਅਕਤੀਗਤ object instance ਨਾਲ ਸੰਬੰਧਿਤ ਹੁੰਦਾ ਹੈ। free-threaded Python ਵਿੱਚ dict ਅਤੇ list ਵਰਗੇ built-in types per-object locks ਵਰਤਦੇ ਹਨ ਤਾਂ ਜੋ ਵੱਖ-ਵੱਖ objects ਉੱਤੇ concurrent operations ਹੋ ਸਕਣ, ਜਦਕਿ ਇੱਕੋ object ਉੱਤੇ operations ਨੂੰ ਕ੍ਰਮਬੱਧ ਕੀਤਾ ਜਾਵੇ। ਜਿਹੜੀਆਂ operations per-object lock ਰੱਖਦੀਆਂ ਹਨ, ਉਹ ਉਸੇ object ਉੱਤੇ ਹੋਰ locking operations ਨੂੰ ਰੋਕਦੀਆਂ ਹਨ, ਪਰ lock-free operations ਨੂੰ ਨਹੀਂ ਰੋਕਦੀਆਂ।

ਪਾਥ ਐਂਟਰੀ

import path ਉੱਤੇ ਇੱਕ ਇਕੱਲੀ location ਜਿਸਨੂੰ path based finder import ਕਰਨ ਲਈ modules ਲੱਭਣ ਵਾਸਤੇ ਵੇਖਦਾ ਹੈ।

ਪਾਥ ਐਂਟਰੀ ਫਾਈਂਡਰ

sys.path_hooks ਉੱਤੇ ਮੌਜੂਦ callable (ਅਰਥਾਤ path entry hook) ਦੁਆਰਾ ਵਾਪਸ ਕੀਤਾ ਗਿਆ finder, ਜੋ path entry ਦਿੱਤੇ ਜਾਣ 'ਤੇ modules ਨੂੰ ਲੱਭਣਾ ਜਾਣਦਾ ਹੈ।

path entry finders ਦੁਆਰਾ implement ਕੀਤੀਆਂ methods ਲਈ importlib.abc.PathEntryFinder ਵੇਖੋ।

ਪਾਥ ਐਂਟਰੀ ਹੁੱਕ

sys.path_hooks ਸੂਚੀ ਵਿੱਚ ਮੌਜੂਦ ਇੱਕ callable ਜੋ path entry finder ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇਕਰ ਉਸਨੂੰ ਕਿਸੇ ਖਾਸ path entry ਉੱਤੇ modules ਲੱਭਣ ਦਾ ਤਰੀਕਾ ਪਤਾ ਹੋਵੇ।

ਪਾਥ ਆਧਾਰਿਤ ਫਾਈਂਡਰ

ਮੂਲ meta path finders ਵਿੱਚੋਂ ਇੱਕ ਜੋ modules ਲਈ import path ਵਿੱਚ ਖੋਜ ਕਰਦਾ ਹੈ।

ਪਾਥ-ਸਮਾਨ ਆਬਜੈਕਟ

ਇੱਕ ਆਬਜੈਕਟ ਜੋ file system path ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। Path-like object ਜਾਂ ਤਾਂ str ਜਾਂ bytes ਆਬਜੈਕਟ ਹੁੰਦਾ ਹੈ ਜੋ path ਦਰਸਾਉਂਦਾ ਹੈ, ਜਾਂ ਫਿਰ os.PathLike protocol ਨੂੰ ਲਾਗੂ ਕਰਨ ਵਾਲਾ ਆਬਜੈਕਟ ਹੁੰਦਾ ਹੈ। os.PathLike protocol ਨੂੰ ਸਮਰਥਨ ਦੇਣ ਵਾਲੇ ਆਬਜੈਕਟ ਨੂੰ os.fspath() function ਰਾਹੀਂ str ਜਾਂ bytes file system path ਵਿੱਚ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ; os.fsdecode() ਅਤੇ os.fsencode() ਕ੍ਰਮਵਾਰ str ਜਾਂ bytes ਨਤੀਜੇ ਦੀ ਗਾਰੰਟੀ ਦੇਣ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਇਹ PEP 519 ਵਿੱਚ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ ਸੀ।

PEP

Python Enhancement Proposal। ਇੱਕ PEP ਇੱਕ ਡਿਜ਼ਾਇਨ ਦਸਤਾਵੇਜ਼ ਹੁੰਦਾ ਹੈ ਜੋ Python ਕਮਿਊਨਿਟੀ ਨੂੰ ਜਾਣਕਾਰੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜਾਂ Python, ਇਸ ਦੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਜਾਂ ਇਸਦੇ ਵਾਤਾਵਰਣ ਲਈ ਨਵੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਾ ਵੇਰਵਾ ਦਿੰਦਾ ਹੈ। PEPs ਵਿੱਚ ਸੰਖੇਪ ਤਕਨੀਕੀ ਵਿਵਰਣ ਅਤੇ ਪ੍ਰਸਤਾਵਿਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਾ ਤਰਕ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

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

PEP 1 ਵੇਖੋ।

ਹਿੱਸਾ

ਇੱਕ ਹੀ directory ਵਿੱਚ ਫਾਈਲਾਂ ਦਾ ਸਮੂਹ (ਸੰਭਵ ਹੈ zip file ਵਿੱਚ ਸੰਭਾਲਿਆ ਗਿਆ ਹੋਵੇ) ਜੋ PEP 420 ਅਨੁਸਾਰ namespace package ਵਿੱਚ ਯੋਗਦਾਨ ਪਾਉਂਦਾ ਹੈ।

ਸਥਿਤੀ-ਆਧਾਰਿਤ ਆਰਗੂਮੈਂਟ

argument ਵੇਖੋ।

ਅਸਥਾਈ API

ਅਸਥਾਈ API ਉਹ ਹੁੰਦੀ ਹੈ ਜਿਸਨੂੰ ਜਾਣ-ਬੁੱਝ ਕੇ standard library ਦੀ backward compatibility ਗਾਰੰਟੀ ਤੋਂ ਬਾਹਰ ਰੱਖਿਆ ਗਿਆ ਹੋਵੇ। ਹਾਲਾਂਕਿ ਐਸੀਆਂ interfaces ਵਿੱਚ ਵੱਡੇ ਬਦਲਾਵਾਂ ਦੀ ਉਮੀਦ ਨਹੀਂ ਹੁੰਦੀ, ਪਰ ਜਦ ਤੱਕ ਉਹ provisional ਚਿੰਨ੍ਹਿਤ ਹਨ, core developers ਦੀ ਲੋੜ ਅਨੁਸਾਰ backward incompatible ਬਦਲਾਅ (ਇੱਥੋਂ ਤੱਕ ਕਿ interface ਨੂੰ ਹਟਾਉਣਾ ਵੀ) ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਐਸੇ ਬਦਲਾਅ ਬਿਨਾਂ ਕਾਰਨ ਨਹੀਂ ਕੀਤੇ ਜਾਣਗੇ; ਇਹ ਸਿਰਫ਼ ਉਸ ਵੇਲੇ ਕੀਤੇ ਜਾਣਗੇ ਜਦੋਂ API ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਛੁੱਟ ਗਈਆਂ ਗੰਭੀਰ ਮੂਲ ਖਾਮੀਆਂ ਸਾਹਮਣੇ ਆਉਣ।

ਅਸਥਾਈ APIs ਲਈ ਵੀ backward incompatible ਬਦਲਾਵਾਂ ਨੂੰ "ਆਖਰੀ ਹੱਲ" ਵਜੋਂ ਵੇਖਿਆ ਜਾਂਦਾ ਹੈ — ਪਛਾਣੀਆਂ ਗਈਆਂ ਸਮੱਸਿਆਵਾਂ ਲਈ backward compatible ਹੱਲ ਲੱਭਣ ਦੀ ਹਰ ਸੰਭਵ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਜਾਵੇਗੀ।

ਇਹ ਪ੍ਰਕਿਰਿਆ standard library ਨੂੰ ਸਮੇਂ ਦੇ ਨਾਲ ਵਿਕਸਿਤ ਹੋਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਬਿਨਾਂ ਸਮੱਸਿਆਪੂਰਨ ਡਿਜ਼ਾਇਨ ਗਲਤੀਆਂ ਨੂੰ ਲੰਬੇ ਸਮੇਂ ਲਈ ਸਥਿਰ ਕੀਤੇ। ਹੋਰ ਵੇਰਵਿਆਂ ਲਈ PEP 411 ਵੇਖੋ।

ਅਸਥਾਈ ਪੈਕੇਜ

provisional API ਵੇਖੋ।

Python 3000

Python 3.x release ਲੜੀ ਲਈ ਵਰਤਿਆ ਜਾਣ ਵਾਲਾ ਉਪਨਾਮ (ਜਦੋਂ version 3 ਦੀ release ਕਾਫ਼ੀ ਦੂਰਲੇ ਭਵਿੱਖ ਦੀ ਗੱਲ ਸੀ ਤਦੋਂ ਇਹ ਨਾਮ ਰੱਖਿਆ ਗਿਆ ਸੀ)। ਇਸਨੂੰ ਸੰਖੇਪ ਵਿੱਚ "Py3k" ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।

ਪਾਇਥੋਨਿਕ

ਕੋਈ ਵਿਚਾਰ ਜਾਂ ਕੋਡ ਦਾ ਹਿੱਸਾ ਜੋ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਦੇ ਆਮ ਸਿਧਾਂਤਾਂ ਦੀ ਬਜਾਇ Python ਭਾਸ਼ਾ ਦੇ ਸਭ ਤੋਂ ਆਮ idioms ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, Python ਵਿੱਚ ਇੱਕ ਆਮ idiom for statement ਦੀ ਵਰਤੋਂ ਕਰਕੇ iterable ਦੇ ਸਾਰੇ elements ਉੱਤੇ loop ਚਲਾਉਣਾ ਹੈ। ਕਈ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਇਹ ਬਣਤਰ ਨਹੀਂ ਹੁੰਦੀ, ਇਸ ਲਈ Python ਨਾਲ ਅਣਜਾਣ ਲੋਕ ਕਈ ਵਾਰ ਇਸਦੀ ਥਾਂ ਸੰਖਿਆਤਮਕ counter ਵਰਤਦੇ ਹਨ:

for i in range(len(food)):
    print(food[i])

ਇਸਦੇ ਉਲਟ ਹੋਰ ਸਾਫ਼ ਅਤੇ Pythonic ਤਰੀਕਾ ਇਹ ਹੈ:

for piece in food:
    print(piece)

ਯੋਗ ਨਾਮ

ਇੱਕ dotted ਨਾਮ ਜੋ PEP 3155 ਅਨੁਸਾਰ ਕਿਸੇ module ਦੇ global scope ਤੋਂ ਉਸ module ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ class, function ਜਾਂ method ਤੱਕ ਦਾ "path" ਦਰਸਾਉਂਦਾ ਹੈ। Top-level functions ਅਤੇ classes ਲਈ qualified name ਆਬਜੈਕਟ ਦੇ ਨਾਮ ਦੇ ਬਰਾਬਰ ਹੁੰਦਾ ਹੈ:

>>> class C:
...     class D:
...         def meth(self):
...             pass
...
>>> C.__qualname__
'C'
>>> C.D.__qualname__
'C.D'
>>> C.D.meth.__qualname__
'C.D.meth'

ਜਦੋਂ modules ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, fully qualified name ਦਾ ਅਰਥ module ਤੱਕ ਪੂਰਾ dotted path ਹੁੰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਸਾਰੇ parent packages ਵੀ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ, ਜਿਵੇਂ email.mime.text:

>>> import email.mime.text
>>> email.mime.text.__name__
'email.mime.text'

ਰੇਸ ਕੰਡੀਸ਼ਨ

ਪ੍ਰੋਗਰਾਮ ਦੀ ਉਹ ਸਥਿਤੀ ਜਿੱਥੇ ਵਿਹਾਰ ਘਟਨਾਵਾਂ ਦੇ ਆਪਸੀ ਸਮੇਂ ਜਾਂ ਕ੍ਰਮ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਖ਼ਾਸ ਕਰਕੇ multi-threaded ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ। Race conditions non-deterministic ਵਿਹਾਰ ਅਤੇ ਅਜਿਹੀਆਂ ਗਲਤੀਆਂ ਦਾ ਕਾਰਣ ਬਣ ਸਕਦੀਆਂ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਦੁਬਾਰਾ ਪੈਦਾ ਕਰਨਾ ਮੁਸ਼ਕਲ ਹੁੰਦਾ ਹੈ। data race race condition ਦੀ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਕਿਸਮ ਹੈ ਜਿਸ ਵਿੱਚ shared memory ਤੱਕ ਬਿਨਾਂ synchronization ਦੇ ਪਹੁੰਚ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ। LBYL coding style multi-threaded code ਵਿੱਚ race conditions ਲਈ ਖ਼ਾਸ ਤੌਰ 'ਤੇ ਸੰਵੇਦਨਸ਼ੀਲ ਹੁੰਦੀ ਹੈ। locks ਅਤੇ ਹੋਰ synchronization primitives ਦੀ ਵਰਤੋਂ race conditions ਨੂੰ ਰੋਕਣ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ।

ਰੈਫਰੈਂਸ ਗਿਣਤੀ

ਕਿਸੇ ਆਬਜੈਕਟ ਲਈ references ਦੀ ਗਿਣਤੀ। ਜਦੋਂ ਕਿਸੇ ਆਬਜੈਕਟ ਦੀ reference count ਸ਼ੂਨਯ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਉਸਨੂੰ deallocate ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਕੁਝ ਆਬਜੈਕਟ immortal ਹੁੰਦੇ ਹਨ ਅਤੇ ਉਨ੍ਹਾਂ ਦੀ reference count ਕਦੇ ਬਦਲੀ ਨਹੀਂ ਜਾਂਦੀ, ਇਸ ਲਈ ਉਹ ਕਦੇ deallocate ਨਹੀਂ ਹੁੰਦੇ। Reference counting ਆਮ ਤੌਰ 'ਤੇ Python code ਵਿੱਚ ਦਿਖਾਈ ਨਹੀਂ ਦਿੰਦੀ, ਪਰ ਇਹ CPython implementation ਦਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਹਿੱਸਾ ਹੈ। Programmers ਕਿਸੇ ਖ਼ਾਸ ਆਬਜੈਕਟ ਦੀ reference count ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ sys.getrefcount() function ਵਰਤ ਸਕਦੇ ਹਨ।

CPython ਵਿੱਚ reference counts ਨੂੰ ਸਥਿਰ ਜਾਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਪਰਿਭਾਸ਼ਿਤ ਮੁੱਲ ਨਹੀਂ ਮੰਨਿਆ ਜਾਂਦਾ; ਕਿਸੇ ਆਬਜੈਕਟ ਲਈ references ਦੀ ਗਿਣਤੀ ਅਤੇ Python code ਦੁਆਰਾ ਉਸ ਗਿਣਤੀ ਉੱਤੇ ਪੈਣ ਵਾਲਾ ਅਸਰ ਵੱਖ-ਵੱਖ versions ਵਿੱਚ ਵੱਖਰਾ ਹੋ ਸਕਦਾ ਹੈ।

ਨਿਯਮਤ ਪੈਕੇਜ

ਇੱਕ ਪਰੰਪਰਾਗਤ package, ਜਿਵੇਂ ਕਿ ਉਹ directory ਜਿਸ ਵਿੱਚ __init__.py ਫਾਈਲ ਹੋਵੇ।

namespace package ਵੀ ਵੇਖੋ।

ਰੀਐਂਟ੍ਰੈਂਟ

ਕਿਸੇ function ਜਾਂ lock ਦੀ ਉਹ ਵਿਸ਼ੇਸ਼ਤਾ ਜੋ ਇੱਕੋ thread ਨੂੰ ਇਸਨੂੰ ਬਾਰ-ਬਾਰ call ਕਰਨ ਜਾਂ acquire ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ ਬਿਨਾਂ ਗਲਤੀਆਂ ਜਾਂ deadlock ਪੈਦਾ ਕੀਤੇ।

Functions ਲਈ reentrancy ਦਾ ਅਰਥ ਹੈ ਕਿ function ਨੂੰ ਪਿਛਲੀ call ਪੂਰੀ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਵੀ ਸੁਰੱਖਿਅਤ ਤਰੀਕੇ ਨਾਲ ਦੁਬਾਰਾ call ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ ਉਸ ਵੇਲੇ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ ਜਦੋਂ functions ਨੂੰ recursively ਜਾਂ signal handlers ਤੋਂ call ਕੀਤਾ ਜਾਂਦਾ ਹੈ। Thread-unsafe functions, ਜੇਕਰ multithreaded ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ reentrantly call ਕੀਤੀਆਂ ਜਾਣ, ਤਾਂ non-deterministic ਹੋ ਸਕਦੀਆਂ ਹਨ।

Locks ਲਈ, Python ਦਾ threading.RLock (reentrant lock) reentrant ਹੁੰਦਾ ਹੈ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ lock ਰੱਖਣ ਵਾਲਾ thread ਇਸਨੂੰ ਦੁਬਾਰਾ acquire ਕਰ ਸਕਦਾ ਹੈ ਬਿਨਾਂ block ਹੋਏ। ਇਸਦੇ ਉਲਟ, threading.Lock reentrant ਨਹੀਂ ਹੁੰਦਾ — ਇੱਕੋ thread ਵੱਲੋਂ ਇਸਨੂੰ ਦੋ ਵਾਰ acquire ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ deadlock ਪੈਦਾ ਕਰੇਗੀ।

lock ਅਤੇ deadlock ਵੀ ਵੇਖੋ।

REPL

"read–eval–print loop" ਦਾ ਸੰਖੇਪ ਰੂਪ, ਜੋ interactive interpreter shell ਦਾ ਇੱਕ ਹੋਰ ਨਾਮ ਹੈ।

__slots__

ਕਿਸੇ class ਦੇ ਅੰਦਰ ਇੱਕ declaration ਜੋ instance attributes ਲਈ ਪਹਿਲਾਂ ਹੀ ਜਗ੍ਹਾ ਨਿਰਧਾਰਤ ਕਰਕੇ ਅਤੇ instance dictionaries ਨੂੰ ਹਟਾਕੇ memory ਬਚਾਉਂਦੀ ਹੈ। ਹਾਲਾਂਕਿ ਇਹ ਕਾਫ਼ੀ ਪ੍ਰਸਿੱਧ ਹੈ, ਪਰ ਇਸ ਤਕਨੀਕ ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਵਰਤਣਾ ਕੁਝ ਮੁਸ਼ਕਲ ਹੋ ਸਕਦਾ ਹੈ ਅਤੇ ਇਹ ਉਹਨਾਂ ਵਿਰਲੇ ਮਾਮਲਿਆਂ ਲਈ ਸਭ ਤੋਂ ਉਚਿਤ ਹੈ ਜਿੱਥੇ memory-critical application ਵਿੱਚ instances ਦੀ ਗਿਣਤੀ ਬਹੁਤ ਵੱਧ ਹੋਵੇ।

ਲੜੀ

ਇੱਕ iterable ਜੋ __getitem__() special method ਰਾਹੀਂ integer indices ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤੱਤਾਂ ਤੱਕ ਕੁਸ਼ਲ ਪਹੁੰਚ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਅਤੇ __len__() method ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਜੋ ਲੜੀ ਦੀ ਲੰਬਾਈ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਕੁਝ built-in sequence types list, str, tuple ਅਤੇ bytes ਹਨ। ਧਿਆਨ ਰਹੇ ਕਿ dict ਵੀ __getitem__() ਅਤੇ __len__() ਨੂੰ ਸਮਰਥਨ ਦਿੰਦਾ ਹੈ, ਪਰ ਇਸਨੂੰ sequence ਦੀ ਬਜਾਏ mapping ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ lookups integers ਦੀ ਥਾਂ ਮਨਮਾਨੀਆਂ hashable keys ਵਰਤਦੇ ਹਨ।

collections.abc.Sequence abstract base class ਇੱਕ ਹੋਰ ਵਿਆਪਕ interface ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀ ਹੈ ਜੋ ਕੇਵਲ __getitem__() ਅਤੇ __len__() ਤੱਕ ਸੀਮਿਤ ਨਹੀਂ ਹੈ, ਸਗੋਂ count(), index(), __contains__() ਅਤੇ __reversed__() ਵੀ ਸ਼ਾਮਲ ਕਰਦੀ ਹੈ। ਇਸ ਵਿਸਤ੍ਰਿਤ interface ਨੂੰ ਲਾਗੂ ਕਰਨ ਵਾਲੇ types ਨੂੰ register() ਰਾਹੀਂ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ register ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। Sequence methods ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ Common Sequence Operations ਵੇਖੋ।

ਸੈੱਟ ਕੰਪ੍ਰਿਹੈਂਸ਼ਨ

ਕਿਸੇ iterable ਦੇ ਸਾਰੇ ਜਾਂ ਕੁਝ ਤੱਤਾਂ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਕਰਕੇ ਨਤੀਜੇ ਵਜੋਂ ਇੱਕ set ਵਾਪਸ ਕਰਨ ਦਾ ਸੰਖੇਪ ਤਰੀਕਾ। results = {c for c in 'abracadabra' if c not in 'abc'} ਸਟਰਿੰਗਾਂ ਦਾ set {'r', 'd'} ਬਣਾਉਂਦਾ ਹੈ। Comprehensions ਵੇਖੋ।

ਸਿੰਗਲ ਡਿਸਪੈਚ

generic function dispatch ਦਾ ਇੱਕ ਰੂਪ ਜਿਸ ਵਿੱਚ implementation ਇੱਕ ਹੀ argument ਦੇ type ਦੇ ਆਧਾਰ 'ਤੇ ਚੁਣੀ ਜਾਂਦੀ ਹੈ।

ਸਲਾਈਸ

slice type ਦਾ ਇੱਕ object ਜੋ sequence ਦੇ ਕਿਸੇ ਹਿੱਸੇ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। Slice object ਉਸ ਵੇਲੇ ਬਣਦਾ ਹੈ ਜਦੋਂ subscript notation ਦੇ slicing ਰੂਪ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ square brackets ਦੇ ਅੰਦਰ colons ਹੁੰਦੇ ਹਨ, ਜਿਵੇਂ variable_name[1:3:5]।

ਸਾਫਟ ਡਿਪ੍ਰਿਕੇਟਿਡ

Soft deprecated API ਨੂੰ ਨਵੇਂ code ਵਿੱਚ ਨਹੀਂ ਵਰਤਣਾ ਚਾਹੀਦਾ, ਪਰ ਪਹਿਲਾਂ ਤੋਂ ਮੌਜੂਦ code ਵਿੱਚ ਇਸਦੀ ਵਰਤੋਂ ਸੁਰੱਖਿਅਤ ਹੈ। API ਦਾ ਦਸਤਾਵੇਜ਼ੀਕਰਨ ਅਤੇ ਟੈਸਟਿੰਗ ਜਾਰੀ ਰਹਿੰਦੀ ਹੈ, ਪਰ ਇਸ ਵਿੱਚ ਹੋਰ ਸੁਧਾਰ ਨਹੀਂ ਕੀਤੇ ਜਾਣਗੇ।

Soft deprecation, ਆਮ deprecation ਤੋਂ ਵੱਖਰਾ, API ਨੂੰ ਹਟਾਉਣ ਦੀ ਯੋਜਨਾ ਨਹੀਂ ਰੱਖਦਾ ਅਤੇ ਕੋਈ warnings ਵੀ ਜਾਰੀ ਨਹੀਂ ਕਰਦਾ।

PEP 387: Soft Deprecation ਵੇਖੋ।

ਵਿਸ਼ੇਸ਼ ਮੈਥਡ

ਇੱਕ method ਜਿਸਨੂੰ Python ਕਿਸੇ type ਉੱਤੇ ਖ਼ਾਸ operation, ਜਿਵੇਂ addition, ਕਰਨ ਲਈ ਆਪਣੇ ਆਪ call ਕਰਦਾ ਹੈ। ਅਜਿਹੇ methods ਦੇ ਨਾਮ double underscores ਨਾਲ ਸ਼ੁਰੂ ਅਤੇ ਖ਼ਤਮ ਹੁੰਦੇ ਹਨ। Special methods ਦਾ ਵੇਰਵਾ Special method names ਵਿੱਚ ਦਿੱਤਾ ਗਿਆ ਹੈ।

ਮਿਆਰੀ ਲਾਇਬ੍ਰੇਰੀ

ਅਧਿਕਾਰਿਕ Python interpreter package ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਵੰਡੇ ਜਾਣ ਵਾਲੇ packages, modules ਅਤੇ extension modules ਦਾ ਸੰਗ੍ਰਹਿ। ਇਸ ਸੰਗ੍ਰਹਿ ਦੀ ਸਹੀ ਸਮੱਗਰੀ platform, ਉਪਲਬਧ system libraries ਜਾਂ ਹੋਰ ਮਾਪਦੰਡਾਂ ਅਨੁਸਾਰ ਬਦਲ ਸਕਦੀ ਹੈ। ਇਸਦਾ ਦਸਤਾਵੇਜ਼ੀਕਰਨ The Python standard library ਵਿੱਚ ਮਿਲ ਸਕਦਾ ਹੈ।

ਸਾਰੇ ਸੰਭਾਵਿਤ standard library module names ਦੀ ਸੂਚੀ ਲਈ sys.stdlib_module_names ਵੀ ਵੇਖੋ।

ਸਟੇਟਮੈਂਟ

Statement ਇੱਕ suite (code ਦਾ "block") ਦਾ ਹਿੱਸਾ ਹੁੰਦਾ ਹੈ। Statement ਜਾਂ ਤਾਂ ਇੱਕ expression ਹੁੰਦਾ ਹੈ ਜਾਂ keyword ਵਾਲੀਆਂ ਕਈ ਬਣਤਰਾਂ ਵਿੱਚੋਂ ਇੱਕ, ਜਿਵੇਂ if, while ਜਾਂ for।

ਸਟੈਟਿਕ ਟਾਈਪ ਚੈੱਕਰ

ਇੱਕ ਬਾਹਰੀ ਟੂਲ ਜੋ Python code ਨੂੰ ਪੜ੍ਹਦਾ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਦਾ ਹੈ, ਅਤੇ ਗਲਤ types ਵਰਗੀਆਂ ਸਮੱਸਿਆਵਾਂ ਲੱਭਦਾ ਹੈ। type hints ਅਤੇ typing module ਵੀ ਵੇਖੋ।

stdlib

standard library ਦਾ ਸੰਖੇਪ ਰੂਪ।

ਚੋਰੀ ਕਰਨਾ

Python ਦੇ C API ਵਿੱਚ, "stealing" ਇੱਕ ਆਰਗੂਮੈਂਟ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਆਰਗੂਮੈਂਟ ਦੀ ਮਾਲਕੀ ਬੁਲਾਏ ਗਏ ਫੰਕਸ਼ਨ ਨੂੰ ਸੌਂਪ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ। ਕਾਲ ਕਰਨ ਵਾਲੇ ਨੂੰ ਕਾਲ ਤੋਂ ਬਾਅਦ ਉਸ ਰੈਫਰੈਂਸ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਨੀ ਚਾਹੀਦੀ। ਆਮ ਤੌਰ 'ਤੇ, ਉਹ ਫੰਕਸ਼ਨ ਜੋ ਆਰਗੂਮੈਂਟ "steal" ਕਰਦੇ ਹਨ, ਉਹ ਫੇਲ ਹੋਣ 'ਤੇ ਵੀ ਇਹ ਕੰਮ ਕਰਦੇ ਹਨ।

ਪੂਰੀ ਵਿਆਖਿਆ ਲਈ Reference Count Details ਵੇਖੋ।

ਮਜ਼ਬੂਤ ਰੈਫਰੈਂਸ

Python ਦੀ C API ਵਿੱਚ, strong reference ਕਿਸੇ ਆਬਜੈਕਟ ਲਈ ਉਹ reference ਹੁੰਦਾ ਹੈ ਜਿਸਦੀ ਮਾਲਕੀ ਉਸ code ਕੋਲ ਹੁੰਦੀ ਹੈ ਜੋ reference ਨੂੰ ਰੱਖਦਾ ਹੈ। Strong reference reference ਬਣਾਉਣ ਵੇਲੇ Py_INCREF() ਨੂੰ call ਕਰਕੇ ਲਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ reference ਮਿਟਾਉਣ ਵੇਲੇ Py_DECREF() ਨਾਲ ਰਿਲੀਜ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

Py_NewRef() function ਦੀ ਵਰਤੋਂ ਕਿਸੇ ਆਬਜੈਕਟ ਲਈ strong reference ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਆਮ ਤੌਰ 'ਤੇ, strong reference ਦੇ scope ਤੋਂ ਬਾਹਰ ਨਿਕਲਣ ਤੋਂ ਪਹਿਲਾਂ Py_DECREF() ਨੂੰ call ਕਰਨਾ ਲਾਜ਼ਮੀ ਹੁੰਦਾ ਹੈ ਤਾਂ ਜੋ reference leak ਨਾ ਹੋਵੇ।

borrowed reference ਵੀ ਵੇਖੋ।

ਸਬਸਕ੍ਰਿਪਟ

subscription expression ਵਿੱਚ square brackets ਦੇ ਅੰਦਰ ਦੀ expression, ਉਦਾਹਰਨ ਲਈ items[3] ਵਿੱਚ 3। ਇਹ ਆਮ ਤੌਰ 'ਤੇ container ਦੇ ਕਿਸੇ ਤੱਤ ਨੂੰ ਚੁਣਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। mapping ਨੂੰ subscript ਕਰਨ ਵੇਲੇ ਇਸਨੂੰ key ਅਤੇ sequence ਨੂੰ subscript ਕਰਨ ਵੇਲੇ index ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।

ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ ਪ੍ਰਿਮਿਟਿਵ

Shared resources ਤੱਕ thread-safe ਪਹੁੰਚ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਈ threads ਦੀ execution ਨੂੰ coordinate (synchronize) ਕਰਨ ਵਾਲਾ ਬੁਨਿਆਦੀ building block। Python ਦਾ threading module ਕਈ synchronization primitives ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ Lock, RLock, Semaphore, Condition, Event ਅਤੇ Barrier। ਇਸ ਤੋਂ ਇਲਾਵਾ, queue module multi-producer ਅਤੇ multi-consumer queues ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ multithreaded ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਖ਼ਾਸ ਤੌਰ 'ਤੇ ਲਾਭਕਾਰੀ ਹਨ। ਇਹ primitives race conditions ਨੂੰ ਰੋਕਣ ਅਤੇ thread execution ਨੂੰ coordinate ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੀਆਂ ਹਨ। lock ਵੀ ਵੇਖੋ।

t-string

t-strings

t ਜਾਂ T ਨਾਲ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲੇ string literals ਨੂੰ ਆਮ ਤੌਰ 'ਤੇ "t-strings" ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਜੋ template string literals ਦਾ ਸੰਖੇਪ ਰੂਪ ਹੈ।

ਟੈਕਸਟ ਐਨਕੋਡਿੰਗ

Python ਵਿੱਚ ਇੱਕ string Unicode code points (ਸੀਮਾ U+0000--U+10FFFF) ਦੀ ਲੜੀ ਹੁੰਦੀ ਹੈ। ਕਿਸੇ string ਨੂੰ ਸੰਭਾਲਣ ਜਾਂ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਲਈ ਇਸਨੂੰ bytes ਦੀ ਲੜੀ ਵਜੋਂ serialize ਕਰਨਾ ਪੈਂਦਾ ਹੈ।

String ਨੂੰ bytes ਦੀ ਲੜੀ ਵਿੱਚ serialize ਕਰਨ ਨੂੰ "encoding" ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ bytes ਦੀ ਲੜੀ ਤੋਂ string ਨੂੰ ਦੁਬਾਰਾ ਬਣਾਉਣ ਨੂੰ "decoding" ਕਿਹਾ ਜਾਂਦਾ ਹੈ।

ਵੱਖ-ਵੱਖ ਕਿਸਮ ਦੇ text serialization codecs ਮੌਜੂਦ ਹਨ, ਜਿਨ੍ਹਾਂ ਨੂੰ ਇਕੱਠੇ ਮਿਲਾ ਕੇ "text encodings" ਕਿਹਾ ਜਾਂਦਾ ਹੈ।

ਟੈਕਸਟ ਫਾਈਲ

ਇੱਕ file object ਜੋ str objects ਨੂੰ ਪੜ੍ਹ ਅਤੇ ਲਿਖ ਸਕਦਾ ਹੈ। ਅਕਸਰ text file ਅਸਲ ਵਿੱਚ byte-oriented datastream ਤੱਕ ਪਹੁੰਚ ਕਰਦੀ ਹੈ ਅਤੇ text encoding ਨੂੰ ਆਪਣੇ ਆਪ ਸੰਭਾਲਦੀ ਹੈ। Text files ਦੇ ਉਦਾਹਰਨਾਂ ਵਿੱਚ text mode ('r' ਜਾਂ 'w') ਵਿੱਚ ਖੋਲ੍ਹੀਆਂ ਫਾਈਲਾਂ, sys.stdin, sys.stdout, ਅਤੇ io.StringIO ਦੇ instances ਸ਼ਾਮਲ ਹਨ।

bytes-like objects ਨੂੰ ਪੜ੍ਹਣ ਅਤੇ ਲਿਖਣ ਯੋਗ file object ਲਈ binary file ਵੀ ਵੇਖੋ।

ਥ੍ਰੈਡ ਸਟੇਟ

ਉਹ ਜਾਣਕਾਰੀ ਜੋ CPython runtime ਵੱਲੋਂ ਕਿਸੇ OS thread ਵਿੱਚ ਚਲਾਉਣ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, ਇਸ ਵਿੱਚ ਮੌਜੂਦਾ exception ਜੇ ਹੋਵੇ ਅਤੇ bytecode interpreter ਦੀ ਸਥਿਤੀ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ।

ਹਰ thread state ਇੱਕ ਹੀ OS thread ਨਾਲ ਜੁੜੀ ਹੁੰਦੀ ਹੈ, ਪਰ threads ਕੋਲ ਕਈ thread states ਉਪਲਬਧ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਇੱਕ ਸਮੇਂ 'ਤੇ ਉਨ੍ਹਾਂ ਵਿੱਚੋਂ ਵੱਧ ਤੋਂ ਵੱਧ ਇੱਕ ਹੀ attached ਹੋ ਸਕਦੀ ਹੈ।

Python ਦੀ ਜ਼ਿਆਦਾਤਰ C API ਨੂੰ call ਕਰਨ ਲਈ attached thread state ਲੋੜੀਂਦੀ ਹੁੰਦੀ ਹੈ, ਜਦੋਂ ਤੱਕ ਕੋਈ function ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਕੁਝ ਹੋਰ ਨਾ ਦੱਸੇ। Bytecode interpreter ਕੇਵਲ attached thread state ਹੇਠਾਂ ਹੀ ਚਲਦਾ ਹੈ।

ਹਰ thread state ਇੱਕ ਹੀ interpreter ਨਾਲ ਸੰਬੰਧਿਤ ਹੁੰਦੀ ਹੈ, ਪਰ ਹਰ interpreter ਕੋਲ ਕਈ thread states ਹੋ ਸਕਦੀਆਂ ਹਨ, ਜਿਸ ਵਿੱਚ ਇੱਕੋ OS thread ਲਈ ਕਈ thread states ਵੀ ਸ਼ਾਮਲ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਕਈ interpreters ਦੀਆਂ thread states ਇੱਕੋ thread ਨਾਲ ਜੁੜੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਪਰ ਕਿਸੇ ਵੀ ਸਮੇਂ ਉਸ thread ਵਿੱਚ ਕੇਵਲ ਇੱਕ ਹੀ attached ਹੋ ਸਕਦੀ ਹੈ।

ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਲਈ Thread State and the Global Interpreter Lock ਵੇਖੋ।

ਥ੍ਰੈਡ-ਸੇਫ

ਐਸਾ module, function ਜਾਂ class ਜੋ ਕਈ threads ਦੁਆਰਾ ਇੱਕੋ ਸਮੇਂ ਵਰਤੇ ਜਾਣ 'ਤੇ ਵੀ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਕੰਮ ਕਰੇ। Thread-safe code shared mutable state ਦੀ ਸੁਰੱਖਿਆ ਲਈ ਉਚਿਤ synchronization primitives ਜਿਵੇਂ locks ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਜਾਂ ਇਸ ਤਰ੍ਹਾਂ ਡਿਜ਼ਾਈਨ ਕੀਤਾ ਹੁੰਦਾ ਹੈ ਕਿ shared mutable state ਤੋਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਬਚਿਆ ਜਾ ਸਕੇ। free-threaded build ਵਿੱਚ dict, list ਅਤੇ set ਵਰਗੇ built-in types ਕਈ operations ਨੂੰ thread-safe ਬਣਾਉਣ ਲਈ internal locking ਵਰਤਦੇ ਹਨ, ਹਾਲਾਂਕਿ thread safety ਦੀ ਪੂਰੀ ਗਾਰੰਟੀ ਨਹੀਂ ਹੁੰਦੀ। ਜੋ code thread-safe ਨਹੀਂ ਹੁੰਦਾ, ਉਹ multithreaded ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ race conditions ਅਤੇ data races ਦਾ ਸ਼ਿਕਾਰ ਹੋ ਸਕਦਾ ਹੈ।

ਟੋਕਨ

Source code ਦੀ ਇੱਕ ਛੋਟੀ ਇਕਾਈ, ਜੋ lexical analyzer (ਜਿਸਨੂੰ tokenizer ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ) ਦੁਆਰਾ ਬਣਾਈ ਜਾਂਦੀ ਹੈ। Names, numbers, strings, operators, newlines ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਹੋਰ ਤੱਤ tokens ਰਾਹੀਂ ਦਰਸਾਏ ਜਾਂਦੇ ਹਨ।

tokenize module Python ਦੇ lexical analyzer ਤੱਕ ਪਹੁੰਚ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। token module ਵਿੱਚ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ tokens ਬਾਰੇ ਜਾਣਕਾਰੀ ਹੁੰਦੀ ਹੈ।

ਤਿੰਨ-ਕੋਟ ਵਾਲੀ ਸਟ੍ਰਿੰਗ

ਇੱਕ string ਜੋ ਤਿੰਨ quotation marks (") ਜਾਂ ਤਿੰਨ apostrophes (') ਨਾਲ ਘੇਰੀ ਜਾਂਦੀ ਹੈ। ਭਾਵੇਂ ਇਹ single-quoted strings ਨਾਲੋਂ ਕੋਈ ਵਾਧੂ functionality ਪ੍ਰਦਾਨ ਨਹੀਂ ਕਰਦੀ, ਪਰ ਕਈ ਕਾਰਨਾਂ ਕਰਕੇ ਇਹ ਲਾਭਦਾਇਕ ਹੈ। ਇਹ string ਦੇ ਅੰਦਰ single ਅਤੇ double quotes ਨੂੰ ਬਿਨਾਂ escape ਕੀਤੇ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ ਅਤੇ continuation character ਦੀ ਲੋੜ ਬਿਨਾਂ ਕਈ ਲਾਈਨਾਂ ਤੱਕ ਫੈਲ ਸਕਦੀ ਹੈ, ਜਿਸ ਕਾਰਨ docstrings ਲਿਖਣ ਵੇਲੇ ਇਹ ਖ਼ਾਸ ਤੌਰ 'ਤੇ ਉਪਯੋਗੀ ਹੁੰਦੀ ਹੈ।

ਟਾਈਪ

ਕਿਸੇ Python object ਦੀ type ਇਹ ਨਿਰਧਾਰਤ ਕਰਦੀ ਹੈ ਕਿ ਉਹ ਕਿਸ ਕਿਸਮ ਦਾ object ਹੈ; ਹਰ object ਦੀ ਇੱਕ type ਹੁੰਦੀ ਹੈ। ਕਿਸੇ object ਦੀ type ਨੂੰ ਉਸਦੇ __class__ attribute ਰਾਹੀਂ ਜਾਂ type(obj) ਨਾਲ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਟਾਈਪ ਐਲਿਆਸ

ਕਿਸੇ type ਲਈ ਇੱਕ ਸਮਾਨਾਰਥਕ ਨਾਮ, ਜੋ type ਨੂੰ ਕਿਸੇ identifier ਨਾਲ assign ਕਰਕੇ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ।

Type aliases type hints ਨੂੰ ਸਰਲ ਬਣਾਉਣ ਲਈ ਲਾਭਦਾਇਕ ਹੁੰਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ:

def remove_gray_shades(
        colors: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]:
    pass

ਇਸ ਤਰ੍ਹਾਂ ਹੋਰ ਪੜ੍ਹਨਯੋਗ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ:

Color = tuple[int, int, int]

def remove_gray_shades(colors: list[Color]) -> list[Color]:
    pass

typing ਅਤੇ PEP 484 ਵੇਖੋ, ਜੋ ਇਸ functionality ਦਾ ਵਰਣਨ ਕਰਦੇ ਹਨ।

ਟਾਈਪ ਹਿੰਟ

ਇੱਕ annotation ਜੋ ਕਿਸੇ variable, class attribute ਜਾਂ function parameter ਜਾਂ return value ਲਈ ਉਮੀਦ ਕੀਤੀ ਜਾਣ ਵਾਲੀ type ਦਰਸਾਉਂਦੀ ਹੈ।

Type hints ਵਿਕਲਪਿਕ ਹੁੰਦੇ ਹਨ ਅਤੇ Python ਦੁਆਰਾ ਲਾਗੂ ਨਹੀਂ ਕੀਤੇ ਜਾਂਦੇ, ਪਰ ਇਹ static type checkers ਲਈ ਲਾਭਦਾਇਕ ਹੁੰਦੇ ਹਨ। ਇਹ IDEs ਨੂੰ code completion ਅਤੇ refactoring ਵਿੱਚ ਵੀ ਮਦਦ ਕਰ ਸਕਦੇ ਹਨ।

Global variables, class attributes ਅਤੇ functions ਦੇ type hints ਪਰ local variables ਦੇ ਨਹੀਂ ਨੂੰ typing.get_type_hints() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

typing ਅਤੇ PEP 484 ਵੇਖੋ, ਜੋ ਇਸ functionality ਦਾ ਵਰਣਨ ਕਰਦੇ ਹਨ।

ਯੂਨੀਵਰਸਲ ਨਿਊਲਾਈਨਜ਼

Text streams ਦੀ ਵਿਆਖਿਆ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਜਿਸ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਸਾਰੇ line ending ਵਜੋਂ ਮੰਨੇ ਜਾਂਦੇ ਹਨ: Unix ਦਾ '\n', Windows ਦਾ '\r\n' ਅਤੇ ਪੁਰਾਣੇ Macintosh ਦਾ '\r'। ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਲਈ PEP 278, PEP 3116 ਅਤੇ ਵਾਧੂ ਵਰਤੋਂ ਲਈ bytes.splitlines() ਵੇਖੋ।

ਵੇਰੀਏਬਲ ਐਨੋਟੇਸ਼ਨ

ਕਿਸੇ ਵੇਰੀਏਬਲ ਜਾਂ ਕਲਾਸ ਐਟ੍ਰਿਬਿਊਟ ਦੀ annotation।

ਜਦੋਂ ਕਿਸੇ ਵੇਰੀਏਬਲ ਜਾਂ ਕਲਾਸ ਐਟ੍ਰਿਬਿਊਟ ਨੂੰ annotate ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ assignment ਵਿਕਲਪਿਕ ਹੁੰਦੀ ਹੈ:

class C:
    field: 'annotation'

ਵੇਰੀਏਬਲ annotations ਆਮ ਤੌਰ 'ਤੇ type hints ਲਈ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਉਦਾਹਰਨ ਵਜੋਂ, ਇਹ ਵੇਰੀਏਬਲ int ਮੁੱਲਾਂ ਨੂੰ ਰੱਖਣ ਦੀ ਉਮੀਦ ਰੱਖਦਾ ਹੈ:

count: int = 0

ਵੇਰੀਏਬਲ annotation ਦੀ syntax ਨੂੰ Annotated assignment statements ਭਾਗ ਵਿੱਚ ਸਮਝਾਇਆ ਗਿਆ ਹੈ।

function annotation, PEP 484 ਅਤੇ PEP 526 ਵੇਖੋ, ਜੋ ਇਸ ਸੁਵਿਧਾ ਦਾ ਵਰਣਨ ਕਰਦੇ ਹਨ। Annotations ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਵਧੀਆ ਅਭਿਆਸਾਂ ਲਈ Annotations Best Practices ਵੀ ਵੇਖੋ।

ਵਰਚੁਅਲ ਇਨਵਾਇਰਨਮੈਂਟ

ਇੱਕ ਸਹਿਕਾਰਤਾਪੂਰਵਕ ਅਲੱਗ ਕੀਤਾ ਗਿਆ runtime environment ਜੋ Python ਵਰਤੋਂਕਾਰਾਂ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ Python distribution packages ਨੂੰ install ਅਤੇ upgrade ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ, ਬਿਨਾਂ ਉਸੇ ਸਿਸਟਮ 'ਤੇ ਚੱਲ ਰਹੀਆਂ ਹੋਰ Python ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ ਵਿਹਾਰ ਵਿੱਚ ਦਖ਼ਲ ਪਾਏ।

venv ਵੀ ਵੇਖੋ।

ਵਰਚੁਅਲ ਮਸ਼ੀਨ

ਇੱਕ ਕੰਪਿਊਟਰ ਜੋ ਪੂਰੀ ਤਰ੍ਹਾਂ software ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਹੁੰਦਾ ਹੈ। Python ਦੀ virtual machine bytecode compiler ਦੁਆਰਾ ਬਣਾਏ ਗਏ bytecode ਨੂੰ ਚਲਾਉਂਦੀ ਹੈ।

ਵਾਲਰਸ ਓਪਰੇਟਰ

assignment expression operator := ਨੂੰ ਹਲਕੇ-ਫੁਲਕੇ ਢੰਗ ਨਾਲ ਸੰਬੋਧਨ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ, ਕਿਉਂਕਿ ਸਿਰ ਥੋੜ੍ਹਾ ਮੋੜ ਕੇ ਵੇਖਣ ਤੇ ਇਹ ਕੁਝ ਹੱਦ ਤੱਕ walrus ਵਰਗਾ ਦਿਸਦਾ ਹੈ।

ਜ਼ੈਨ ਆਫ਼ ਪਾਇਥਨ

Python ਦੇ ਡਿਜ਼ਾਈਨ ਸਿਧਾਂਤਾਂ ਅਤੇ ਦਰਸ਼ਨਾਂ ਦੀ ਸੂਚੀ, ਜੋ ਭਾਸ਼ਾ ਨੂੰ ਸਮਝਣ ਅਤੇ ਵਰਤਣ ਵਿੱਚ ਮਦਦਗਾਰ ਹੁੰਦੀ ਹੈ। ਇਹ ਸੂਚੀ interactive prompt 'ਤੇ "import this" ਟਾਈਪ ਕਰਕੇ ਵੇਖੀ ਜਾ ਸਕਦੀ ਹੈ।