ਪਾਈਥਨ ਟਾਈਪ ਚੈਕਰ ਤੁਲਨਾ: ਖਾਲੀ ਕੰਟੇਨਰ ਅਨੁਮਾਨ

ਖਾਲੀ ਕੰਟੇਨਰ ਪਾਈਥਨ ਟਾਈਪ ਚੈਕਰਾਂ ਨੂੰ ਕਿਉਂ ਤੋੜਦੇ ਹਨ — ਅਤੇ ਤੁਸੀਂ ਇਸ ਬਾਰੇ ਕੀ ਕਰ ਸਕਦੇ ਹੋ

ਪਾਈਥਨ ਦੀ ਹੌਲੀ-ਹੌਲੀ ਟਾਈਪਿੰਗ ਪ੍ਰਣਾਲੀ 2015 ਵਿੱਚ PEP 484 ਦੁਆਰਾ ਟਾਈਪ ਹਿੰਟ ਪੇਸ਼ ਕੀਤੇ ਜਾਣ ਤੋਂ ਬਾਅਦ ਕਾਫ਼ੀ ਪਰਿਪੱਕ ਹੋ ਗਈ ਹੈ। ਅੱਜ, ਲੱਖਾਂ ਡਿਵੈਲਪਰ ਉਤਪਾਦਨ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਬੱਗ ਫੜਨ ਲਈ ਸਥਿਰ ਕਿਸਮ ਦੇ ਚੈਕਰਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ। ਪਰ ਟਾਈਪ ਸਿਸਟਮ ਦਾ ਇੱਕ ਸੂਖਮ, ਨਿਰਾਸ਼ਾਜਨਕ ਕੋਨਾ ਹੈ ਜੋ ਅਜੇ ਵੀ ਤਜਰਬੇਕਾਰ ਇੰਜਨੀਅਰਾਂ ਦਾ ਦੌਰਾ ਕਰਦਾ ਹੈ: ਇੱਕ ਖਾਲੀ ਕੰਟੇਨਰ ਵਿੱਚ ਕਿਸ ਕਿਸਮ ਦਾ ਹੁੰਦਾ ਹੈ? ਜਦੋਂ ਤੁਸੀਂ x = [] ਬਿਨਾਂ ਐਨੋਟੇਸ਼ਨ ਦੇ ਲਿਖਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਡੇ ਟਾਈਪ ਚੈਕਰ ਨੂੰ ਅੰਦਾਜ਼ਾ ਲਗਾਉਣਾ ਪੈਂਦਾ ਹੈ — ਅਤੇ ਵੱਖ-ਵੱਖ ਚੈਕਰ ਵੱਖਰੇ ਅੰਦਾਜ਼ਾ ਲਗਾ ਸਕਦੇ ਹਨ। ਇਹ ਵਿਭਿੰਨਤਾ ਵੱਡੇ ਕੋਡਬੇਸ ਨੂੰ ਕਾਇਮ ਰੱਖਣ ਵਾਲੀਆਂ ਟੀਮਾਂ ਲਈ ਅਸਲ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਕਰਦੀ ਹੈ, ਜਿੱਥੇ ਕਿਸਮ ਦੇ ਚੈਕਰਾਂ ਨੂੰ ਬਦਲਣ ਜਾਂ ਜੋੜਨ ਨਾਲ ਰਾਤੋ-ਰਾਤ ਸੈਂਕੜੇ ਅਣਕਿਆਸੀਆਂ ਗਲਤੀਆਂ ਸਾਹਮਣੇ ਆ ਸਕਦੀਆਂ ਹਨ।

ਇਹ ਲੇਖ ਇਸ ਗੱਲ ਨੂੰ ਤੋੜਦਾ ਹੈ ਕਿ ਕਿਵੇਂ ਚਾਰ ਪ੍ਰਮੁੱਖ ਪਾਈਥਨ ਟਾਈਪ ਚੈਕਰਸ — mypy, pyright, pytype, ਅਤੇ pyre — ਖਾਲੀ ਕੰਟੇਨਰ ਇਨਫਰੈਂਸ ਨੂੰ ਹੈਂਡਲ ਕਰਦੇ ਹਨ, ਉਹ ਕਿਉਂ ਅਸਹਿਮਤ ਹਨ, ਅਤੇ ਤੁਹਾਡੀ ਟੂਲਿੰਗ ਚੋਣ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ ਤੁਸੀਂ ਟਾਈਪ-ਸੁਰੱਖਿਅਤ ਪਾਈਥਨ ਲਿਖਣ ਲਈ ਕਿਹੜੀਆਂ ਵਿਹਾਰਕ ਰਣਨੀਤੀਆਂ ਅਪਣਾ ਸਕਦੇ ਹੋ।

ਮੁੱਖ ਸਮੱਸਿਆ: ਖਾਲੀ ਡੱਬੇ ਅੰਦਰੂਨੀ ਤੌਰ 'ਤੇ ਅਸਪਸ਼ਟ ਹਨ

ਪਾਈਥਨ ਦੀ ਇਸ ਨਿਰਦੋਸ਼ ਲਾਈਨ 'ਤੇ ਵਿਚਾਰ ਕਰੋ: ਨਤੀਜੇ = []। ਕੀ ਨਤੀਜੇ ਇੱਕ ਸੂਚੀ[int] ਹਨ? ਇੱਕ ਸੂਚੀ[str]? ਇੱਕ ਸੂਚੀ[dict[str, Any]]? ਵਾਧੂ ਸੰਦਰਭ ਤੋਂ ਬਿਨਾਂ, ਅਸਲ ਵਿੱਚ ਜਾਣਨ ਦਾ ਕੋਈ ਤਰੀਕਾ ਨਹੀਂ ਹੈ। ਪਾਈਥਨ ਰਨਟਾਈਮ ਪਰਵਾਹ ਨਹੀਂ ਕਰਦਾ — ਸੂਚੀਆਂ ਕੁਦਰਤ ਦੁਆਰਾ ਵਿਭਿੰਨ ਹੁੰਦੀਆਂ ਹਨ — ਪਰ ਸਥਿਰ ਕਿਸਮ ਦੇ ਚੈਕਰਾਂ ਨੂੰ ਆਪਣਾ ਕੰਮ ਕਰਨ ਲਈ ਹਰ ਵੇਰੀਏਬਲ ਨੂੰ ਇੱਕ ਠੋਸ ਕਿਸਮ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਹ ਪਾਈਥਨ ਦੀ ਗਤੀਸ਼ੀਲ ਲਚਕਤਾ ਅਤੇ ਗਾਰੰਟੀ ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਬੁਨਿਆਦੀ ਤਣਾਅ ਪੈਦਾ ਕਰਦਾ ਹੈ ਜੋ ਸਥਿਰ ਵਿਸ਼ਲੇਸ਼ਣ ਪ੍ਰਦਾਨ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ।

ਸਮੱਸਿਆ ਸ਼ਬਦਕੋਸ਼ਾਂ ਅਤੇ ਸੈੱਟਾਂ ਨਾਲ ਮਿਲ ਜਾਂਦੀ ਹੈ। ਇੱਕ ਖਾਲੀ {} ਨੂੰ ਅਸਲ ਵਿੱਚ ਇੱਕ dict ਦੇ ਤੌਰ 'ਤੇ ਪਾਰਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਨਾ ਕਿ ਇੱਕ ਸੈੱਟ, ਜੋ ਕਿ ਟਾਈਪ-ਪੱਧਰ ਦੀ ਅਸਪਸ਼ਟਤਾ ਦੇ ਸਿਖਰ 'ਤੇ ਸਿੰਟੈਕਟਿਕ ਅਸਪਸ਼ਟਤਾ ਜੋੜਦਾ ਹੈ। ਅਤੇ ਨੇਸਟਡ ਕੰਟੇਨਰ — ਸੋਚੋ ਡਿਫਾਲਟਡਿਕਟ(ਲਿਸਟ) ਜਾਂ ਨਤੀਜੇ = {k: [] ਕੁੰਜੀਆਂ ਵਿੱਚ k ਲਈ — ਅਨੁਮਾਨ ਇੰਜਣਾਂ ਨੂੰ ਉਹਨਾਂ ਦੀਆਂ ਸੀਮਾਵਾਂ ਵਿੱਚ ਧੱਕੋ। ਹਰੇਕ ਕਿਸਮ ਦੇ ਚੈਕਰ ਨੇ ਆਪਣੀ ਖੁਦ ਦੀ ਹਿਉਰਿਸਟਿਕ ਵਿਕਸਿਤ ਕੀਤੀ ਹੈ, ਅਤੇ ਅੰਤਰ ਜ਼ਿਆਦਾਤਰ ਡਿਵੈਲਪਰਾਂ ਦੇ ਅਨੁਭਵ ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਮਹੱਤਵਪੂਰਨ ਹਨ।

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

Mypy: ਕਿਸੇ ਵੀ ਅਪ੍ਰਤੱਖ ਨਾਲ ਮੁਲਤਵੀ ਅਨੁਮਾਨ

ਮਾਈਪੀ, ਸਭ ਤੋਂ ਪੁਰਾਣਾ ਅਤੇ ਸਭ ਤੋਂ ਵੱਧ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਅਪਣਾਇਆ ਗਿਆ ਪਾਈਥਨ ਟਾਈਪ ਚੈਕਰ, ਖਾਲੀ ਕੰਟੇਨਰਾਂ ਲਈ ਮੁਕਾਬਲਤਨ ਨਰਮ ਪਹੁੰਚ ਅਪਣਾਉਂਦੀ ਹੈ। ਜਦੋਂ ਇਹ ਫੰਕਸ਼ਨ ਸਕੋਪ 'ਤੇ x = [] ਦਾ ਸਾਹਮਣਾ ਕਰਦਾ ਹੈ, ਤਾਂ ਇਹ ਕਿਸਮ ਦੇ ਫੈਸਲੇ ਨੂੰ ਮੁਲਤਵੀ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ ਅਤੇ ਅਗਲੀ ਵਰਤੋਂ ਤੋਂ ਤੱਤ ਦੀ ਕਿਸਮ ਦਾ ਅਨੁਮਾਨ ਲਗਾਉਂਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ x.append(42) ਤੋਂ ਬਾਅਦ x = [] ਲਿਖਦੇ ਹੋ, ਤਾਂ mypy list[int] ਦਾ ਅਨੁਮਾਨ ਲਗਾਏਗਾ। ਇਹ "ਸ਼ਾਮਲ" ਰਣਨੀਤੀ ਸਿੱਧੇ ਮਾਮਲਿਆਂ ਲਈ ਹੈਰਾਨੀਜਨਕ ਤੌਰ 'ਤੇ ਚੰਗੀ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦੀ ਹੈ ਜਿੱਥੇ ਕੰਟੇਨਰ ਉਸੇ ਦਾਇਰੇ ਦੇ ਅੰਦਰ ਆਬਾਦ ਹੁੰਦਾ ਹੈ।

ਹਾਲਾਂਕਿ, ਸੰਦਰਭ ਅਤੇ ਸਖਤੀ ਸੈਟਿੰਗਾਂ ਦੇ ਆਧਾਰ 'ਤੇ mypy ਦਾ ਵਿਵਹਾਰ ਨਾਟਕੀ ਢੰਗ ਨਾਲ ਬਦਲਦਾ ਹੈ। ਮੋਡੀਊਲ ਸਕੋਪ (ਟੌਪ-ਲੈਵਲ ਕੋਡ) 'ਤੇ, ਜਾਂ ਜਦੋਂ ਕੰਟੇਨਰ ਨੂੰ ਆਬਾਦ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਕਿਸੇ ਹੋਰ ਫੰਕਸ਼ਨ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, mypy ਅਕਸਰ ਲਿਸਟ[ਕੋਈ] ਵਿੱਚ ਵਾਪਸ ਆ ਜਾਂਦਾ ਹੈ। --strict ਫਲੈਗ ਦੇ ਤਹਿਤ, ਇਹ ਇੱਕ ਗਲਤੀ ਨੂੰ ਚਾਲੂ ਕਰਦਾ ਹੈ, ਪਰ ਡਿਫੌਲਟ ਮੋਡ ਵਿੱਚ ਇਹ ਚੁੱਪਚਾਪ ਲੰਘ ਜਾਂਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਬਿਨਾਂ ਸਖਤ ਮੋਡ ਦੇ mypy ਚਲਾਉਣ ਵਾਲੀਆਂ ਟੀਮਾਂ ਦਰਜਨਾਂ ਅਪ੍ਰਤੱਖ-ਟਾਈਪ ਕੰਟੇਨਰਾਂ ਨੂੰ ਇਕੱਠਾ ਕਰ ਸਕਦੀਆਂ ਹਨ ਜੋ ਟਾਈਪ ਸਿਸਟਮ ਤੋਂ ਬਚਣ ਲਈ ਕੰਮ ਕਰਦੀਆਂ ਹਨ, ਇਸਦੇ ਉਦੇਸ਼ ਨੂੰ ਹਰਾ ਦਿੰਦੀਆਂ ਹਨ।

ਇੱਕ ਖਾਸ ਤੌਰ 'ਤੇ ਸੂਖਮ ਵਿਵਹਾਰ: 0.990 ਤੋਂ ਪਹਿਲਾਂ ਦੇ mypy ਸੰਸਕਰਣ ਕਈ ਵਾਰ ਅੰਦਰੂਨੀ ਤੌਰ 'ਤੇ ਸੂਚੀ[ਅਣਜਾਣ] ਦਾ ਅਨੁਮਾਨ ਲਗਾਉਂਦੇ ਹਨ ਅਤੇ ਫਿਰ ਅਸਾਈਨਮੈਂਟ 'ਤੇ ਸੂਚੀ[ਕੋਈ] ਤੱਕ ਚੌੜਾ ਕਰਦੇ ਹਨ। 0.990 ਤੋਂ ਬਾਅਦ, ਅਨੁਮਾਨ ਨੂੰ ਸਖ਼ਤ ਕਰ ਦਿੱਤਾ ਗਿਆ ਸੀ, ਪਰ ਤਬਦੀਲੀ ਨੇ ਅਸਲ-ਸੰਸਾਰ ਕੋਡਬੇਸ ਦੀ ਇੱਕ ਹੈਰਾਨੀਜਨਕ ਸੰਖਿਆ ਨੂੰ ਤੋੜ ਦਿੱਤਾ ਜੋ ਇਸ ਨੂੰ ਮਹਿਸੂਸ ਕੀਤੇ ਬਿਨਾਂ ਆਗਿਆਕਾਰੀ ਵਿਵਹਾਰ 'ਤੇ ਭਰੋਸਾ ਕਰ ਰਹੇ ਸਨ। ਇਹ ਇੱਕ ਆਵਰਤੀ ਥੀਮ ਹੈ — ਖਾਲੀ ਕੰਟੇਨਰ ਅਨੁਮਾਨ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਸਭ ਤੋਂ ਵਿਘਨ ਪਾਉਣ ਵਾਲੇ ਕਿਸਮ ਦੇ ਚੈਕਰ ਅੱਪਡੇਟਾਂ ਵਿੱਚੋਂ ਹਨ ਕਿਉਂਕਿ ਪੈਟਰਨ ਬਹੁਤ ਸਰਵ ਵਿਆਪਕ ਹਨ।

ਪਾਈਰਾਈਟ: ਸਖਤ ਅਨੁਮਾਨ ਅਤੇ "ਅਣਜਾਣ" ਕਿਸਮ

ਪਾਈਰਾਈਟ, ਮਾਈਕ੍ਰੋਸਾਫਟ ਦੁਆਰਾ ਵਿਕਸਤ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ VS ਕੋਡ ਵਿੱਚ ਪਾਈਲੈਂਸ ਨੂੰ ਸ਼ਕਤੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਇੱਕ ਬੁਨਿਆਦੀ ਤੌਰ 'ਤੇ ਵੱਖਰਾ ਦਾਰਸ਼ਨਿਕ ਰੁਖ ਰੱਖਦਾ ਹੈ। ਚੁੱਪਚਾਪ ਕਿਸੇ ਵੀ 'ਤੇ ਵਾਪਸ ਜਾਣ ਦੀ ਬਜਾਏ, ਪਾਈਰਾਈਟ ਅਣਜਾਣ (ਇੱਕ ਕਿਸਮ ਜੋ ਅਜੇ ਤੱਕ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤੀ ਗਈ ਹੈ) ਅਤੇ ਕੋਈ ਵੀ (ਕਿਸਮ ਦੀ ਜਾਂਚ ਤੋਂ ਇੱਕ ਸਪਸ਼ਟ ਔਪਟ-ਆਊਟ) ਵਿੱਚ ਫਰਕ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਤੁਸੀਂ ਪਾਈਰਾਈਟ ਦੇ ਸਖਤ ਮੋਡ ਵਿੱਚ x = [] ਲਿਖਦੇ ਹੋ, ਤਾਂ ਇਹ ਸੂਚੀ[ਅਣਜਾਣ] ਦਾ ਅਨੁਮਾਨ ਲਗਾਉਂਦਾ ਹੈ ਅਤੇ ਇੱਕ ਡਾਇਗਨੌਸਟਿਕ ਦੀ ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ, ਤੁਹਾਨੂੰ ਇੱਕ ਐਨੋਟੇਸ਼ਨ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਮਜਬੂਰ ਕਰਦਾ ਹੈ।

ਪਾਈਰਾਈਟ ਦਾਇਰੇ ਵਿੱਚ ਸੰਕੁਚਿਤ ਬਾਰੇ ਵੀ ਵਧੇਰੇ ਹਮਲਾਵਰ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਲਿਖਦੇ ਹੋ:

• x = [] ਤੋਂ ਬਾਅਦ x.append("hello") — pyright infers list[str]
• x = [] ਤੋਂ ਬਾਅਦ x.append(1) ਫਿਰ x.append("hello") — pyright infers list[int | str]
• x = [] list[int] ਦੀ ਉਮੀਦ ਕਰਦੇ ਹੋਏ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਸਿੱਧਾ ਪਾਸ ਕੀਤਾ ਗਿਆ — pyright infers list[int] ਕਾਲ-ਸਾਈਟ ਸੰਦਰਭ
ਤੋਂ
• x = [] ਇੱਕ ਫੰਕਸ਼ਨ ਤੋਂ ਰਿਟਰਨ ਟਾਈਪ ਐਨੋਟੇਸ਼ਨ ਤੋਂ ਬਿਨਾਂ ਵਾਪਸ ਆਇਆ — ਪਾਈਰਾਈਟ ਅਨੁਮਾਨ ਲਗਾਉਣ ਦੀ ਬਜਾਏ ਇੱਕ ਗਲਤੀ ਦੀ ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ

ਇਹ ਦੋ-ਦਿਸ਼ਾਵੀ ਅਨੁਮਾਨ (ਕਾਲ ਸਾਈਟਾਂ ਤੋਂ ਬਾਅਦ ਦੀ ਵਰਤੋਂ ਅਤੇ ਸੰਭਾਵਿਤ ਕਿਸਮਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ) pyright ਨੂੰ ਖਾਲੀ ਕੰਟੇਨਰਾਂ ਲਈ mypy ਨਾਲੋਂ ਖਾਸ ਤੌਰ 'ਤੇ ਵਧੇਰੇ ਸਟੀਕ ਬਣਾਉਂਦਾ ਹੈ। ਟ੍ਰੇਡਆਫ ਵਰਬੋਸਿਟੀ ਹੈ: ਕਈ ਓਪਨ-ਸਰੋਤ ਮਾਈਗਰੇਸ਼ਨ ਰਿਪੋਰਟਾਂ ਦੇ ਵਿਸ਼ਲੇਸ਼ਣ ਦੇ ਅਨੁਸਾਰ, ਮਾਈਪੀ ਦੇ ਸਖਤ ਮੋਡ ਦੀ ਤੁਲਨਾ ਵਿੱਚ ਇੱਕ ਆਮ ਅਣ-ਨੋਟੇਟਿਡ ਕੋਡਬੇਸ 'ਤੇ ਪਾਈਰਾਈਟ ਦਾ ਸਖਤ ਮੋਡ ਲਗਭਗ 30-40% ਵਧੇਰੇ ਮੁੱਦਿਆਂ ਨੂੰ ਫਲੈਗ ਕਰਦਾ ਹੈ। ਗੁੰਝਲਦਾਰ ਬੈਕਐਂਡ ਸਿਸਟਮ ਬਣਾਉਣ ਵਾਲੀਆਂ ਟੀਮਾਂ ਲਈ — ਜਿਵੇਂ ਕਿ, CRM, ਪੇਰੋਲ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ 'ਤੇ ਫੈਲੇ 207 ਆਪਸ ਵਿੱਚ ਜੁੜੇ ਮਾਡਿਊਲਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਵਾਲਾ ਇੱਕ ਪਲੇਟਫਾਰਮ — ਪਾਈਰਾਈਟ ਦੀ ਸਖਤੀ ਸੂਖਮ ਇੰਟਰਫੇਸ ਮੇਲ ਖਾਂਦੀ ਹੈ ਜੋ ਨਰਮ ਅਨੁਮਾਨ ਨੂੰ ਗੁਆ ਦਿੰਦੀ ਹੈ।

Pytype and Pyre: The Less Traveled Roads

ਗੂਗਲ ਦੀ ਪਾਈਟਾਈਪ ਸ਼ਾਇਦ ਸਭ ਤੋਂ ਵਿਹਾਰਕ ਪਹੁੰਚ ਅਪਣਾਉਂਦੀ ਹੈ। ਐਨੋਟੇਸ਼ਨਾਂ ਦੀ ਲੋੜ ਜਾਂ ਕਿਸੇ ਵੀ 'ਤੇ ਵਾਪਸ ਜਾਣ ਦੀ ਬਜਾਏ, ਪਾਈਟਾਈਪ ਇਹ ਟਰੈਕ ਕਰਨ ਲਈ ਪੂਰੇ-ਪ੍ਰੋਗਰਾਮ ਵਿਸ਼ਲੇਸ਼ਣ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਕਿ ਫੰਕਸ਼ਨ ਸੀਮਾਵਾਂ ਵਿੱਚ ਕੰਟੇਨਰ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਵਿੱਚ ਇੱਕ ਖਾਲੀ ਸੂਚੀ ਬਣਾਉਂਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਦੂਜੇ ਵਿੱਚ ਪਾਸ ਕਰਦੇ ਹੋ ਜੋ ਪੂਰਨ ਅੰਕ ਜੋੜਦਾ ਹੈ, ਤਾਂ pytype ਅਕਸਰ ਬਿਨਾਂ ਕਿਸੇ ਐਨੋਟੇਸ਼ਨ ਦੇ list[int] ਦਾ ਅਨੁਮਾਨ ਲਗਾ ਸਕਦਾ ਹੈ। ਇਹ ਕ੍ਰਾਸ-ਫੰਕਸ਼ਨ ਅਨੁਮਾਨ ਗਣਨਾਤਮਕ ਤੌਰ 'ਤੇ ਮਹਿੰਗਾ ਹੈ — ਵੱਡੇ ਕੋਡਬੇਸਾਂ 'ਤੇ ਮਾਈਪੀ ਜਾਂ ਪਾਈਰਾਈਟ ਨਾਲੋਂ ਪਾਈਟਾਈਪ ਕਾਫ਼ੀ ਹੌਲੀ ਹੈ — ਪਰ ਇਹ ਅਣ-ਨੋਟ ਕੀਤੇ ਕੋਡ 'ਤੇ ਘੱਟ ਝੂਠੇ ਸਕਾਰਾਤਮਕ ਪੈਦਾ ਕਰਦਾ ਹੈ।

ਪਾਈਟਾਈਪ ਖਾਲੀ ਕੰਟੇਨਰਾਂ ਲਈ "ਅੰਸ਼ਕ ਕਿਸਮਾਂ" ਦੀ ਧਾਰਨਾ ਵੀ ਪੇਸ਼ ਕਰਦਾ ਹੈ। ਇੱਕ ਤਾਜ਼ਾ ਬਣਾਇਆ ਇੱਕ ਅੰਸ਼ਕ ਕਿਸਮ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਜੋ ਹੌਲੀ-ਹੌਲੀ ਸੁਧਾਰਿਆ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਚੈਕਰ ਵਧੇਰੇ ਵਰਤੋਂ ਦਾ ਸਾਹਮਣਾ ਕਰਦਾ ਹੈ। ਇਹ ਸੰਕਲਪਿਕ ਤੌਰ 'ਤੇ ਸ਼ਾਨਦਾਰ ਹੈ ਪਰ ਜਦੋਂ ਅੰਸ਼ਕ ਕਿਸਮ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਹੱਲ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਤਾਂ ਇਹ ਉਲਝਣ ਵਾਲੇ ਤਰੁਟੀ ਸੁਨੇਹੇ ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਜਦੋਂ ਇੱਕ ਖਾਲੀ ਕੰਟੇਨਰ ਕਈ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚੋਂ ਲੰਘਦਾ ਹੈ, ਬਿਨਾਂ ਕਦੇ ਵੀ ਆਬਾਦੀ ਕੀਤੇ।

ਮੇਟਾ ਦਾ ਚਿਤਾ, ਇਸ ਦੌਰਾਨ, ਮਾਈਪੀ ਦੇ ਵਿਵਹਾਰ ਦੇ ਨੇੜੇ ਹੈ ਪਰ ਸਖ਼ਤ ਡਿਫਾਲਟਸ ਦੇ ਨਾਲ। ਪਾਇਰੇ x = [] ਨੂੰ ਸੂਚੀ[ਅਣਜਾਣ] ਮੰਨਦਾ ਹੈ ਅਤੇ ਜ਼ਿਆਦਾਤਰ ਸੰਦਰਭਾਂ ਵਿੱਚ ਐਨੋਟੇਸ਼ਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਜਿੱਥੇ pyre ਆਪਣੇ ਆਪ ਨੂੰ ਵੱਖ ਕਰਦਾ ਹੈ ਕਵਾਰਗ ਦੇ ਤੌਰ ਤੇ ਵਰਤੇ ਜਾਂਦੇ ਖਾਲੀ ਡਿਕਸ਼ਨਰੀ ਲਿਟਰਲ - ਵੈੱਬ ਫਰੇਮਵਰਕ ਵਿੱਚ ਇੱਕ ਆਮ ਪੈਟਰਨ ਦੇ ਪ੍ਰਬੰਧਨ ਵਿੱਚ ਹੈ। ਪਾਈਰ ਕੋਲ ਕੀਵਰਡ ਆਰਗੂਮੈਂਟ ਪ੍ਰਸੰਗਾਂ ਤੋਂ ਸ਼ਬਦਕੋਸ਼ ਕਿਸਮਾਂ ਦਾ ਅਨੁਮਾਨ ਲਗਾਉਣ ਲਈ ਵਿਸ਼ੇਸ਼-ਕੇਸ ਤਰਕ ਹੈ, ਫਰੇਮਵਰਕ-ਭਾਰੀ ਕੋਡਬੇਸ ਵਿੱਚ ਐਨੋਟੇਸ਼ਨ ਬੋਝ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ। ਇਹ ਦੇਖਦੇ ਹੋਏ ਕਿ ਜ਼ਿਆਦਾਤਰ ਆਧੁਨਿਕ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਸੰਰਚਨਾ ਅਤੇ ਬੇਨਤੀ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਡਿਕਸ਼ਨਰੀ ਅਨਪੈਕਿੰਗ ਦੀ ਭਾਰੀ ਵਰਤੋਂ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ, ਇਹ ਵਿਹਾਰਕਤਾ ਲਾਭਅੰਸ਼ਾਂ ਦਾ ਭੁਗਤਾਨ ਕਰਦੀ ਹੈ।

ਅਸਲ-ਵਿਸ਼ਵ ਪ੍ਰਭਾਵ: ਜਦੋਂ ਇਨਫਰੈਂਸ ਡਾਇਵਰਜੈਂਸ ਕੱਟਦਾ ਹੈ

ਟਾਈਪ ਚੈਕਰਾਂ ਵਿਚਕਾਰ ਅੰਤਰ ਅਕਾਦਮਿਕ ਜਾਪਦੇ ਹਨ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ ਉਤਪਾਦਨ ਕੋਡਬੇਸ ਵਿੱਚ ਅਨੁਭਵ ਨਹੀਂ ਕਰਦੇ। ਕਾਰੋਬਾਰੀ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਇੱਕ ਆਮ ਪੈਟਰਨ 'ਤੇ ਵਿਚਾਰ ਕਰੋ: ਇੱਕ ਡੇਟਾ ਢਾਂਚੇ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨਾ ਜੋ ਕਿ ਸ਼ਰਤ ਅਨੁਸਾਰ ਆਬਾਦ ਹੁੰਦਾ ਹੈ।

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

ਇੱਕ ਠੋਸ ਉਦਾਹਰਨ: ਇੱਕ ਫਿਨਟੇਕ ਸਟਾਰਟਅਪ 'ਤੇ ਇੱਕ ਟੀਮ ਨੇ ਇੱਕ ਉਤਪਾਦਨ ਮੁੱਦੇ ਨੂੰ ਡੀਬੱਗ ਕਰਨ ਵਿੱਚ ਤਿੰਨ ਦਿਨ ਖਰਚ ਕਰਨ ਦੀ ਰਿਪੋਰਟ ਕੀਤੀ ਜਿੱਥੇ ਇੱਕ ਖਾਲੀ ਸੂਚੀ, ਇੱਕ ਭੁਗਤਾਨ ਪ੍ਰੋਸੈਸਿੰਗ ਫੰਕਸ਼ਨ ਵਿੱਚ ਅਰੰਭ ਕੀਤੀ ਗਈ, ਨੂੰ mypy ਦੁਆਰਾ ਲਿਸਟ[ਕੋਈ] ਦੇ ਰੂਪ ਵਿੱਚ ਅਨੁਮਾਨ ਲਗਾਇਆ ਗਿਆ ਸੀ। ਸੂਚੀ ਵਿੱਚ ਮੁਦਰਾ ਦੀ ਮਾਤਰਾ ਲਈ ਦਸ਼ਮਲਵ ਵਸਤੂਆਂ ਸ਼ਾਮਲ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ ਸਨ, ਪਰ ਇਸਦੀ ਬਜਾਏ ਇੱਕ ਕੋਡ ਮਾਰਗ ਫਲੋਟ ਮੁੱਲ ਜੋੜ ਰਿਹਾ ਸੀ। ਮਾਈਪੀ ਦੇ ਨਰਮ ਅਨੁਮਾਨ ਨੇ ਚੁੱਪਚਾਪ ਇਸ ਦੀ ਇਜਾਜ਼ਤ ਦਿੱਤੀ. ਇਹ ਬੱਗ ਉਦੋਂ ਹੀ ਸਾਹਮਣੇ ਆਇਆ ਜਦੋਂ ਫਲੋਟ ਅੰਕਗਣਿਤ ਵਿੱਚ 12,000 ਇਨਵੌਇਸਾਂ ਦੇ ਇੱਕ ਬੈਚ ਵਿੱਚ $0.01 ਦੀ ਗੜਬੜ ਦਾ ਕਾਰਨ ਬਣ ਗਿਆ। ਜੇਕਰ ਉਹਨਾਂ ਨੇ ਸਖਤ ਮੋਡ ਵਿੱਚ ਪਾਈਰਾਈਟ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੁੰਦੀ, ਜਾਂ ਖਾਲੀ ਸੂਚੀ ਨੂੰ ਸੂਚੀ[ਦਸ਼ਮਲਵ] ਦੇ ਰੂਪ ਵਿੱਚ ਵਿਆਖਿਆ ਕੀਤੀ ਹੁੰਦੀ, ਤਾਂ ਬੱਗ ਵਿਕਾਸ ਦੇ ਸਮੇਂ ਫੜਿਆ ਗਿਆ ਹੁੰਦਾ।

ਮੇਵੇਜ਼ ਵਿਖੇ, ਜਿੱਥੇ ਪਲੇਟਫਾਰਮ 138,000+ ਉਪਭੋਗਤਾ ਖਾਤਿਆਂ ਵਿੱਚ ਇਨਵੌਇਸਿੰਗ, ਪੇਰੋਲ ਗਣਨਾਵਾਂ, ਅਤੇ ਵਿੱਤੀ ਵਿਸ਼ਲੇਸ਼ਣਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਦਾ ਹੈ, ਇਸ ਕਿਸਮ ਦੀ ਸੁਰੱਖਿਆ ਅੰਤਰ ਸਿਧਾਂਤਕ ਨਹੀਂ ਹੈ — ਇਹ ਸਹੀ ਪੇਰੋਲ ਰਨ ਅਤੇ ਮਹਿੰਗੇ ਪੁਨਰ-ਗਣਨਾਵਾਂ ਵਿੱਚ ਅੰਤਰ ਹੈ। ਕੰਟੇਨਰ ਦੀ ਸ਼ੁਰੂਆਤ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਸਖ਼ਤ ਟਾਈਪਿੰਗ ਅਨੁਸ਼ਾਸਨ ਉਹਨਾਂ "ਬੋਰਿੰਗ" ਇੰਜਨੀਅਰਿੰਗ ਅਭਿਆਸਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ ਜੋ ਉਤਪਾਦਨ ਦੀਆਂ ਦਿਲਚਸਪ ਘਟਨਾਵਾਂ ਨੂੰ ਰੋਕਦਾ ਹੈ।

ਰੱਖਿਆਤਮਕ ਕੰਟੇਨਰ ਦੀ ਸ਼ੁਰੂਆਤ ਲਈ ਵਧੀਆ ਅਭਿਆਸ

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

1. ਹਮੇਸ਼ਾ ਖਾਲੀ ਕੰਟੇਨਰ ਵੇਰੀਏਬਲ ਦੀ ਵਿਆਖਿਆ ਕਰੋ। ਨਤੀਜੇ = [] ਦੀ ਬਜਾਏ ਨਤੀਜੇ: ਸੂਚੀ[int] = [] ਲਿਖੋ। ਬਚੇ ਹੋਏ ਡੀਬੱਗਿੰਗ ਸਮੇਂ ਦੀ ਤੁਲਨਾ ਵਿੱਚ ਮਾਮੂਲੀ ਵਰਬੋਸਿਟੀ ਦੀ ਲਾਗਤ ਬਹੁਤ ਘੱਟ ਹੈ। ਇਹ ਇੱਕਲਾ ਅਭਿਆਸ ਲਗਭਗ 80% ਖਾਲੀ ਕੰਟੇਨਰ ਅਨੁਮਾਨ ਮੁੱਦਿਆਂ ਨੂੰ ਖਤਮ ਕਰਦਾ ਹੈ।
2. ਜਟਿਲ ਕੰਟੇਨਰਾਂ ਲਈ ਫੈਕਟਰੀ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ। cache = {} ਦੀ ਬਜਾਏ, def make_cache() -> dict[str, list[UserRecord]]: ਵਾਪਸੀ {} ਵਰਗਾ ਇੱਕ ਫੰਕਸ਼ਨ ਲਿਖੋ। ਰਿਟਰਨ ਟਾਈਪ ਐਨੋਟੇਸ਼ਨ ਇੱਛਤ ਕਿਸਮ ਨੂੰ ਅਸਪਸ਼ਟ ਅਤੇ ਸਵੈ-ਦਸਤਾਵੇਜ਼ੀ ਬਣਾਉਂਦਾ ਹੈ।
3. ਗੈਰ-ਮਾਮੂਲੀ ਕਿਸਮਾਂ ਲਈ ਲਿਟਰਲ ਨਾਲੋਂ ਟਾਈਪ ਕੀਤੇ ਕੰਸਟਰਕਟਰਾਂ ਨੂੰ ਤਰਜੀਹ ਦਿਓ। ਸੈੱਟ ਸਮਝ ਅਨੁਮਾਨ 'ਤੇ ਭਰੋਸਾ ਕਰਨ ਦੀ ਬਜਾਏ ਆਈਟਮਾਂ: set[int] = set() ਲਿਖੋ। ਡਿਫਾਲਟਡਿਕਟ ਅਤੇ ਕਾਊਂਟਰ ਲਈ, ਹਮੇਸ਼ਾ ਟਾਈਪ ਪੈਰਾਮੀਟਰ ਪ੍ਰਦਾਨ ਕਰੋ: counts: Counter[str] = Counter()।
4. ਨਵੇਂ ਕੋਡ ਲਈ ਆਪਣੇ ਟਾਈਪ ਚੈਕਰ ਦੇ ਸਖਤ ਮੋਡ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰੋ। ਮਾਈਪੀ ਅਤੇ ਪਾਈਰਾਈਟ ਦੋਵੇਂ ਪ੍ਰਤੀ-ਫਾਈਲ ਜਾਂ ਪ੍ਰਤੀ-ਡਾਇਰੈਕਟਰੀ ਸੰਰਚਨਾ ਦਾ ਸਮਰਥਨ ਕਰਦੇ ਹਨ। ਪੁਰਾਤਨ ਕੋਡ ਨੂੰ ਹੌਲੀ-ਹੌਲੀ ਮਾਈਗ੍ਰੇਟ ਕਰਦੇ ਹੋਏ ਨਵੇਂ ਮਾਡਿਊਲਾਂ 'ਤੇ ਸਖਤ ਜਾਂਚ ਨੂੰ ਸਮਰੱਥ ਬਣਾਓ। ਇਹ ਨਵੇਂ ਅਪ੍ਰਤੱਖ-ਟਾਈਪ ਕੰਟੇਨਰਾਂ ਨੂੰ ਇਕੱਠਾ ਹੋਣ ਤੋਂ ਰੋਕਦਾ ਹੈ।
5. ਤੁਹਾਡੀ CI ਪਾਈਪਲਾਈਨ ਦੀ ਤੁਲਨਾ ਵਿੱਚ ਟਾਈਪ ਚੈਕਰ ਸ਼ਾਮਲ ਕਰੋ। ਤੁਹਾਡੇ ਕੋਡਬੇਸ 'ਤੇ mypy ਅਤੇ pyright ਦੋਨਾਂ ਨੂੰ ਚਲਾਉਣ ਨਾਲ ਅਨੁਮਾਨ ਵਿਭਿੰਨਤਾ ਨੂੰ ਜਲਦੀ ਫੜਿਆ ਜਾਂਦਾ ਹੈ। ਜੇਕਰ ਇੱਕ ਪੈਟਰਨ ਇੱਕ ਚੈਕਰ ਨੂੰ ਪਾਸ ਕਰਦਾ ਹੈ ਪਰ ਦੂਜੇ ਵਿੱਚ ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਇੱਕ ਸੰਕੇਤ ਹੈ ਕਿ ਕਿਸਮ ਕਾਫ਼ੀ ਸਪੱਸ਼ਟ ਨਹੀਂ ਹੈ।

ਵੱਡੀ ਤਸਵੀਰ: ਇੱਕ ਟੀਮ ਅਭਿਆਸ ਦੇ ਤੌਰ 'ਤੇ ਚੈਕਿੰਗ ਟਾਈਪ ਕਰੋ

ਖਾਲੀ ਕੰਟੇਨਰ ਦਾ ਅੰਦਾਜ਼ਾ ਆਖਿਰਕਾਰ ਪਾਈਥਨ ਦੀ ਕਿਸਮ ਪ੍ਰਣਾਲੀ ਵਿੱਚ ਇੱਕ ਵੱਡੀ ਚੁਣੌਤੀ ਦਾ ਇੱਕ ਸੂਖਮ ਰੂਪ ਹੈ: ਸਹੂਲਤ ਅਤੇ ਸੁਰੱਖਿਆ ਵਿਚਕਾਰ ਤਣਾਅ। ਪਾਈਥਨ ਦਾ ਫਲਸਫਾ "ਅਸੀਂ ਸਾਰੇ ਬਾਲਗ ਸਹਿਮਤ ਹਾਂ" ਪ੍ਰੋਟੋਟਾਈਪਿੰਗ ਅਤੇ ਸਕ੍ਰਿਪਟਾਂ ਲਈ ਸੁੰਦਰਤਾ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ, ਪਰ ਹਜ਼ਾਰਾਂ ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਸੇਵਾ ਕਰਨ ਵਾਲੇ ਉਤਪਾਦਨ ਪ੍ਰਣਾਲੀਆਂ ਨੂੰ ਮਜ਼ਬੂਤ ​​ਗਾਰੰਟੀਆਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਹ ਤੱਥ ਕਿ ਚਾਰ ਪ੍ਰਮੁੱਖ ਕਿਸਮ ਦੇ ਚੈਕਰ [] ਦੀ ਕਿਸਮ ਦੇ ਰੂਪ ਵਿੱਚ ਬੁਨਿਆਦੀ ਤੌਰ 'ਤੇ ਕਿਸੇ ਚੀਜ਼ 'ਤੇ ਅਸਹਿਮਤ ਹੁੰਦੇ ਹਨ ਕਿ ਪਾਈਥਨ ਟਾਈਪਿੰਗ ਈਕੋਸਿਸਟਮ ਅਜੇ ਵੀ ਪਰਿਪੱਕ ਹੋ ਰਿਹਾ ਹੈ।

ਜਟਿਲ ਪਲੇਟਫਾਰਮ ਬਣਾਉਣ ਵਾਲੀਆਂ ਇੰਜਨੀਅਰਿੰਗ ਟੀਮਾਂ ਲਈ — ਭਾਵੇਂ ਤੁਸੀਂ ਮੁੱਠੀ ਭਰ ਮਾਈਕ੍ਰੋਸੇਵਾਵਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰ ਰਹੇ ਹੋ ਜਾਂ Mewayz ਦੇ ਕਾਰੋਬਾਰੀ OS ਵਰਗੇ ਸੈਂਕੜੇ ਆਪਸ ਵਿੱਚ ਜੁੜੇ ਮਾਡਿਊਲਾਂ ਨਾਲ ਇੱਕ ਏਕੀਕ੍ਰਿਤ ਸਿਸਟਮ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰ ਰਹੇ ਹੋ — ਵਿਹਾਰਕ ਸਲਾਹ ਸਿੱਧੀ ਹੈ: ਖਾਲੀ ਕੰਟੇਨਰਾਂ ਲਈ ਅਨੁਮਾਨ 'ਤੇ ਭਰੋਸਾ ਨਾ ਕਰੋ, ਇੱਕ ਟਾਈਪ ਚੈਕਰ ਚੁਣੋ ਅਤੇ ਇਸਨੂੰ ਸਖਤੀ ਨਾਲ ਸੰਰਚਿਤ ਕਰੋ, ਜੋ ਦਸਤਾਵੇਜ਼ ਦੀ ਕਿਸਮ ਦੇ ਤੌਰ 'ਤੇ ਵਾਪਰਦਾ ਹੈ। ਮਸ਼ੀਨ-ਪੁਸ਼ਟੀਯੋਗ. [/////

ਜਿਵੇਂ ਕਿ PEP 696 (ਡਿਫੌਲਟ ਟਾਈਪ ਪੈਰਾਮੀਟਰ) ਅਤੇ PEP 695 (ਟਾਈਪ ਪੈਰਾਮੀਟਰ ਸਿੰਟੈਕਸ) ਨਵੇਂ ਪਾਈਥਨ ਸੰਸਕਰਣਾਂ ਵਿੱਚ ਉਤਰਨਾ ਜਾਰੀ ਰੱਖਦੇ ਹਨ, ਸਪੱਸ਼ਟ ਟਾਈਪਿੰਗ ਦੇ ਐਰਗੋਨੋਮਿਕਸ ਵਿੱਚ ਸੁਧਾਰ ਹੁੰਦਾ ਰਹੇਗਾ। "ਐਨੋਟੇਟਿਡ" ਅਤੇ "ਅਨੋਟੇਟਿਡ" ਪਾਈਥਨ ਵਿਚਕਾਰ ਅੰਤਰ ਘੱਟ ਜਾਵੇਗਾ। ਪਰ ਉਸ ਦਿਨ ਤੱਕ, ਸਪੱਸ਼ਟ ਕੰਟੇਨਰ ਕਿਸਮਾਂ ਪਾਈਥਨ ਡਿਵੈਲਪਰ ਦੇ ਟੂਲਕਿੱਟ ਵਿੱਚ ਸਭ ਤੋਂ ਉੱਚੇ-ਆਰਓਆਈ ਅਭਿਆਸਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹਨ — ਇੱਕ ਛੋਟਾ ਅਨੁਸ਼ਾਸਨ ਜੋ ਹਰ ਮੋਡੀਊਲ, ਹਰ ਸਪ੍ਰਿੰਟ, ਅਤੇ ਹਰ ਉਤਪਾਦਨ ਤੈਨਾਤੀ ਵਿੱਚ ਮਿਸ਼ਰਿਤ ਵਿਆਜ ਦਾ ਭੁਗਤਾਨ ਕਰਦਾ ਹੈ।