# ਪਾਈਥਨ ਪ੍ਰਦਰਸ਼ਨ: ਨੇਟਿਵ ਨੰਪਾਈ ਲੂਪਸ, ਕਾਲਬੈਕ ਅਤੇ ਪਰਿਵਰਤਨ ਲਾਗਤਾਂ

Published: 2026-10-17

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

Canonical: https://thedailydiff.dev/pa/video/2026-10-17-python-native-loops/

## ਇਹ ਵੀਡੀਓ ਕੀ ਕਵਰ ਕਰਦਾ ਹੈ

- CPython ਸਰੋਤ ਨੂੰ ਬਾਈਟਕੋਡ ਵਿੱਚ ਕੰਪਾਇਲ ਕਰਦਾ ਹੈ। ਦੁਹਰਾਇਆ ਗਿਆ ਇੰਟਰਪ੍ਰੇਟਰ/ਆਬਜੈਕਟ ਕੰਮ ਅਤੇ ਇੱਕ ਟਾਈਪਡ ਨੇਟਿਵ ਸੰਖਿਆਤਮਕ ਲੂਪ ਵੱਖਰੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਪ੍ਰਬੰਧ ਹਨ।
- ਸੰਖਿਆਤਮਕ ਨੰਪਾਈ ਅੰਕਗਣਿਤ ਕੰਪਾਇਲ ਕੀਤੀਆਂ ਕਾਰਵਾਈਆਂ ਨੂੰ ਟਾਈਪਡ ਬੈਚ ਸੌਂਪ ਸਕਦਾ ਹੈ; ਅੰਕਗਣਿਤ ਲੂਪ ਅਜੇ ਵੀ ਮੌਜੂਦ ਹੈ, ਅਤੇ ਵਿਊਜ਼ ਵਿੱਚ ਗੈਰ-ਸੰਬੰਧਿਤ ਲੇਆਉਟ ਹੋ ਸਕਦੇ ਹਨ।
- ਪਰਿਵਰਤਨ ਅਤੇ ਲੋੜੀਂਦੇ ਆਉਟਪੁੱਟ ਪ੍ਰਤੀਨਿਧਤਾ ਨੂੰ ਮਾਪੋ। ਇਸ ਦੌੜ ਵਿੱਚ, ਪਾਈਥਨ ਸੂਚੀਆਂ ਨੂੰ ਐਰੇ ਵਿੱਚ ਬਦਲਣ ਅਤੇ ਵਾਪਸ ਬਦਲਣ ਨਾਲ ਵੱਡੀ ਤਿਆਰ-ਐਰੇ ਲੀਡ ਮਿਟ ਗਈ।
- ਛੋਟੇ ਕਾਰਜਭਾਰ ਆਮ ਪਾਈਥਨ ਦਾ ਪੱਖ ਲੈ ਸਕਦੇ ਹਨ ਕਿਉਂਕਿ ਨਿਸ਼ਚਿਤ ਐਰੇ-ਕਾਲ ਲਾਗਤਾਂ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦੀਆਂ ਹਨ। ਅੱਠ-ਮੁੱਲ ਸਮਝ ਨੇ ਇਸ ਮਾਪੀ ਗਈ ਤੁਲਨਾ ਨੂੰ ਜਿੱਤਿਆ।
- np.vectorize ਇੱਕ ਸੁਵਿਧਾਜਨਕ ਰੈਪਰ ਹੈ ਜੋ ਲਗਾਤਾਰ ਤੱਤਾਂ ਲਈ ਪਾਈਥਨ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ; ਇੱਕ ਬੈਚ ਇੰਟਰਫੇਸ ਇਕੱਲਾ ਨੇਟਿਵ ਸੰਖਿਆਤਮਕ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸਥਾਪਤ ਨਹੀਂ ਕਰਦਾ।
- ਕੰਪਾਇਲ ਕੀਤੇ ਪਾਈਥਨ-ਸਿੰਟੈਕਸ ਲੂਪਸ ਵੀ ਤੇਜ਼ ਹੋ ਸਕਦੇ ਹਨ। ਕਾਲਰ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੋਣ 'ਤੇ ਕੋਲਡ ਕੰਪਾਈਲੇਸ਼ਨ/ਸੈੱਟਅੱਪ ਲਾਗਤਾਂ ਸ਼ਾਮਲ ਕਰੋ।
- ਨੇਟਿਵ ਐਗਜ਼ੀਕਿਊਸ਼ਨ, CPU SIMD, ਮਲਟੀਥ੍ਰੈਡਿੰਗ ਅਤੇ GPU ਬੈਕਐਂਡ ਵੱਖਰੇ ਵਿਚਾਰ ਹਨ। ਉਪਲਬਧ CPU ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਇੱਕ ਖਾਸ ਰਨ ਵਿੱਚ ਵਰਤੇ ਗਏ ਨਿਰਦੇਸ਼ਾਂ ਦਾ ਪਤਾ ਨਹੀਂ ਲਗਾਉਂਦੀਆਂ।

## ਅਧਿਆਇ

- 0:00 ਉਹੀ CPU ਜਲਦੀ ਕਿਉਂ ਖਤਮ ਹੋ ਸਕਦਾ ਹੈ?
- 0:52 ਇੱਕ ਪਾਈਥਨ ਲੂਪ ਕਿਹੜਾ ਕੰਮ ਦੁਹਰਾਉਂਦਾ ਹੈ?
- 1:38 ਨੰਪਾਈ ਲੂਪ ਨੂੰ ਕਿੱਥੇ ਲੈ ਜਾਂਦਾ ਹੈ?
- 2:13 ਕੀ ਤੇਜ਼ ਦਾ ਮਤਲਬ GPU ਜਾਂ ਬਹੁਤ ਸਾਰੇ CPU ਕੋਰ ਹਨ?
- 2:49 ਸ਼ਾਨਦਾਰ ਸਪੀਡਅਪ ਕਦੋਂ ਗਾਇਬ ਹੋ ਜਾਂਦਾ ਹੈ?
- 3:28 ਬੈਂਚਮਾਰਕ ਵਿੱਚ ਕਿਹੜੀਆਂ ਸੀਮਾਵਾਂ ਸ਼ਾਮਲ ਹਨ?
- 4:00 ਕੀ ਇੱਕ ਕੰਪਾਇਲ ਕੀਤਾ ਪਾਈਥਨ ਲੂਪ ਵੀ ਤੇਜ਼ ਹੋ ਸਕਦਾ ਹੈ?
- 4:56 np.vectorize ਅਸਲ ਵਿੱਚ ਕੀ ਚਲਾਉਂਦਾ ਹੈ?
- 5:41 ਤੁਹਾਨੂੰ ਆਪਣੇ ਕੋਡ ਵਿੱਚ ਕੀ ਬਦਲਣਾ ਚਾਹੀਦਾ ਹੈ?

## ਅਨੁਵਾਦਿਤ ਟ੍ਰਾਂਸਕ੍ਰਿਪਟ

ਮੂਲ ਅੰਗਰੇਜ਼ੀ ਬਿਰਤਾਂਤ ਤੋਂ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ। ਉਪਲਬਧ ਆਡੀਓ ਅਤੇ ਕੈਪਸ਼ਨ YouTube ਦੁਆਰਾ ਨਿਯੰਤਰਿਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।

### ਉਹੀ CPU ਜਲਦੀ ਕਿਉਂ ਖਤਮ ਹੋ ਸਕਦਾ ਹੈ?

0:00 ਤੁਸੀਂ ਸੋਚਦੇ ਹੋ ਕਿ ਪਾਈਥਨ ਨੂੰ ਤੇਜ਼ ਹੋਣ ਲਈ ਇੱਕ ਨਵੀਂ ਭਾਸ਼ਾ ਦੀ ਲੋੜ ਹੈ। ਲੂਪ ਦੇ ਅੱਗੇ ਵਧਣ ਤੋਂ ਬਾਅਦ ਉਸੇ CPU ਨੇ ਸਾਡੇ ਬੈਚ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਚਲਾਇਆ। ਕੰਮ ਕਿੱਥੇ ਗਿਆ? ਸਪੀਡਅਪ ਕਦੋਂ ਗਾਇਬ ਹੋ ਜਾਂਦਾ ਹੈ? ਕਿਹੜਾ ਸ਼ਾਰਟਕੱਟ ਪਾਈਥਨ ਨੂੰ ਵਾਪਸ ਲਿਆਉਂਦਾ ਹੈ? ਇਹ The Daily Diff ਹੈ, ਅੰਦਰੂਨੀ ਤੌਰ 'ਤੇ। ਉਸ ਸ਼ਾਰਟਕੱਟ 'ਤੇ ਨਜ਼ਰ ਰੱਖੋ। CPython ਸਟੈਂਡਰਡ ਪਾਈਥਨ ਲਾਗੂਕਰਨ ਹੈ।

0:17 ਇਹ ਤੁਹਾਡੇ ਸਰੋਤ ਨੂੰ ਬਾਈਟਕੋਡ ਵਿੱਚ ਕੰਪਾਇਲ ਕਰਦਾ ਹੈ, ਫਿਰ ਉਹਨਾਂ ਨਿਰਦੇਸ਼ਾਂ ਨੂੰ ਇੱਕ ਇੰਟਰਪ੍ਰੇਟਰ ਵਿੱਚ ਚਲਾਉਂਦਾ ਹੈ। NumPy ਇੱਕ ਸੰਖਿਆਤਮਕ ਲਾਇਬ੍ਰੇਰੀ ਹੈ ਜਿਸਦੇ ਐਰੇ ਵਿੱਚ ਇੱਕ ਘੋਸ਼ਿਤ ਡੇਟਾ ਕਿਸਮ ਦੇ ਨਾਲ ਮੁੱਲ ਹੁੰਦੇ ਹਨ। ਇਸਦਾ ਬਿਲਟ-ਇਨ ਅੰਕਗਣਿਤ ਕੰਪਾਇਲ ਕੀਤੀਆਂ ਕਾਰਵਾਈਆਂ ਨੂੰ ਪੂਰਾ ਬੈਚ ਸੌਂਪ ਸਕਦਾ ਹੈ। ਇੱਕ ਮਿਲੀਅਨ ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਮੁੱਲ ਲਓ, ਹਰ ਇੱਕ ਦਾ ਵਰਗ ਕਰੋ, ਫਿਰ ਅਸਲ ਮੁੱਲ ਜੋੜੋ। ਹਰ ਸੰਸਕਰਣ ਨੂੰ ਇੱਕੋ ਜਿਹੇ ਮੁੱਲ ਮਿਲਦੇ ਹਨ ਅਤੇ ਮੇਲ ਖਾਂਦੇ ਜਵਾਬ ਪੈਦਾ ਕਰਦਾ ਹੈ। ਮੁੱਲ ਇੰਨੇ ਛੋਟੇ ਹਨ ਕਿ ਉਹ ਰਾਉਂਡਿੰਗ ਦੇ ਅੰਤਰ ਨੂੰ ਦੌੜ ਤੋਂ ਬਾਹਰ ਰੱਖਦੇ ਹਨ।

0:40 ਇਸ ਮਸ਼ੀਨ 'ਤੇ, ਸਮਝ ਵਿੱਚ ਲਗਭਗ ਤੇਤੀ ਮਿਲੀਸਕਿੰਟ ਲੱਗੇ। ਨੰਪਾਈ ਨੂੰ ਇੱਕ ਤੋਂ ਘੱਟ ਲੱਗਿਆ। ਦੋਵੇਂ CPU 'ਤੇ ਚੱਲੇ। ਇਹ ਇਸ ਕਾਰਜਭਾਰ ਲਈ ਉਪਯੋਗੀ ਸਬੂਤ ਹੈ, ਅਤੇ ਇੱਕ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਲਈ ਇੱਕ ਭਿਆਨਕ ਸ਼ਰਧਾਂਜਲੀ। ਆਮ ਲੂਪ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ। ਪਾਈਥਨ ਅਗਲਾ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਅੰਕਗਣਿਤ ਕਰਦਾ ਹੈ, ਅਤੇ ਜਵਾਬ ਜੋੜਦਾ ਹੈ।

### ਇੱਕ ਪਾਈਥਨ ਲੂਪ ਕਿਹੜਾ ਕੰਮ ਦੁਹਰਾਉਂਦਾ ਹੈ?

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

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

1:36 ਇਹ ਐਰੇ ਇੱਕ ਘੋਸ਼ਿਤ ਕਿਸਮ ਦੇ ਨਾਲ ਨਿਸ਼ਚਿਤ ਆਕਾਰ ਦੇ ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਮੁੱਲ ਰੱਖਦਾ ਹੈ।

### ਨੰਪਾਈ ਲੂਪ ਨੂੰ ਕਿੱਥੇ ਲੈ ਜਾਂਦਾ ਹੈ?

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

2:00 ਬੈਚ ਇੰਟਰਫੇਸ, ਨੇਟਿਵ ਲਾਗੂਕਰਨ ਅਤੇ ਪ੍ਰੋਸੈਸਰ ਵੈਕਟਰ ਨਿਰਦੇਸ਼ ਵੱਖਰੀਆਂ ਚੀਜ਼ਾਂ ਹਨ। ਫੰਕਸ਼ਨ ਦਾ ਨਾਮ ਬਹੁਤ ਘੱਟ ਸਬੂਤ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਇਸ ਨਤੀਜੇ ਨੇ CPU 'ਤੇ ਨੰਪਾਈ ਦੀ ਵਰਤੋਂ ਕੀਤੀ। ਕੁਪਾਈ ਵਰਗਾ ਇੱਕ GPU ਬੈਕਐਂਡ ਐਰੇ ਅਤੇ ਕਾਰਵਾਈਆਂ ਲਈ ਇੱਕ ਵੱਖਰਾ ਘਰ ਚੁਣਦਾ ਹੈ। ਇੱਕ GPU ਖਰੀਦਣ ਨਾਲ ਇਹ ਆਮ ਪਾਈਥਨ ਲੂਪ ਉੱਥੇ ਚੱਲਦਾ ਰਹਿੰਦਾ ਹੈ ਜਿੱਥੇ ਇਹ ਪਹਿਲਾਂ ਹੀ ਚੱਲ ਰਿਹਾ ਸੀ।

### ਕੀ ਤੇਜ਼ ਦਾ ਮਤਲਬ GPU ਜਾਂ ਬਹੁਤ ਸਾਰੇ CPU ਕੋਰ ਹਨ?

2:13 CPU ਵੈਕਟਰ ਨਿਰਦੇਸ਼ ਕਈ ਮੁੱਲਾਂ ਨੂੰ ਇਕੱਠੇ ਪ੍ਰੋਸੈਸ ਕਰ ਸਕਦੇ ਹਨ। ਨੰਪਾਈ ਕੋਲ ਸਮਰਥਿਤ ਕਰਨਲ ਚੁਣਨ ਲਈ ਮਸ਼ੀਨਰੀ ਹੈ। ਸਾਡਾ ਰਨਟਾਈਮ ਉਪਲਬਧ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ, ਪਰ ਇਸ ਸਮੀਕਰਨ ਦੇ ਨਿਰਦੇਸ਼ਾਂ ਦਾ ਪਤਾ ਨਹੀਂ ਲਗਾਉਂਦਾ। ਵੈਕਟਰ ਨਿਰਦੇਸ਼ਾਂ ਨੂੰ ਪੂਰਾ ਮਾਪਿਆ ਲਾਭ ਦੇਣ ਨਾਲ ਸਬੂਤ ਨੂੰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਵੇਚਿਆ ਜਾਵੇਗਾ। GPU ਸ਼ਾਪਿੰਗ ਕਾਰਟ ਬੰਦ ਰਹਿ ਸਕਦਾ ਹੈ। ਪ੍ਰਦਰਸ਼ਨ ਫਿਕਸ ਬਾਰੇ ਕੁਝ ਬਹੁਤ ਹੀ ਸੰਤੁਸ਼ਟੀਜਨਕ ਹੈ ਜੋ ਇੱਕ ਖਰੀਦ ਨੂੰ ਵੀ ਰੱਦ ਕਰਦਾ ਹੈ। ਬਦਕਿਸਮਤੀ ਨਾਲ, ਬੈਂਚਮਾਰਕ ਜਾਰੀ ਰਹਿੰਦਾ ਹੈ।

2:40 ਅੱਠ ਮੁੱਲਾਂ ਦੇ ਨਾਲ, ਸਮਝ ਨੇ ਜਿੱਤ ਪ੍ਰਾਪਤ ਕੀਤੀ। ਐਰੇ ਮਸ਼ੀਨਰੀ ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਕੀਮਤ ਛੋਟੇ ਕੰਮ ਨਾਲੋਂ ਵੱਧ ਸੀ। ਵੱਡੇ ਤਿਆਰ ਐਰੇ ਅੱਗੇ ਵਧ ਗਏ।

### ਸ਼ਾਨਦਾਰ ਸਪੀਡਅਪ ਕਦੋਂ ਗਾਇਬ ਹੋ ਜਾਂਦਾ ਹੈ?

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

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

### ਬੈਂਚਮਾਰਕ ਵਿੱਚ ਕਿਹੜੀਆਂ ਸੀਮਾਵਾਂ ਸ਼ਾਮਲ ਹਨ?

3:28 ਉਹਨਾਂ ਕ੍ਰਾਸਿੰਗਾਂ ਨੂੰ ਮਾਪੋ। ਇੱਕ ਮਹਿੰਗੇ ਹੈਂਡਆਫ ਤੋਂ ਪਹਿਲਾਂ ਰੁਕਣਾ ਗਲਤ ਸਵਾਲ ਲਈ ਸਹੀ ਸੰਖਿਆਵਾਂ ਦਿੰਦਾ ਹੈ। ਇਸ ਐਰੇ ਨੂੰ ਗੁਣਾ ਕਰਨ ਨਾਲ ਇੱਕ ਅਸਥਾਈ ਨਤੀਜਾ ਬਣਦਾ ਹੈ। ਅਸਲ ਮੁੱਲਾਂ ਨੂੰ ਜੋੜਨ ਨਾਲ ਆਉਟਪੁੱਟ ਬਣਦੀ ਹੈ। ਨੇਟਿਵ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਅਜੇ ਵੀ ਮੈਮੋਰੀ ਅਤੇ ਡੇਟਾ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਕੁਝ ਕਾਰਵਾਈਆਂ ਇੱਕ ਆਉਟਪੁੱਟ ਬਫਰ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦੀਆਂ ਹਨ, ਜਦੋਂ ਤੁਹਾਡਾ ਕੋਡ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਇਸਨੂੰ ਦੁਬਾਰਾ ਵਰਤ ਸਕਦਾ ਹੈ, ਤਾਂ ਵੰਡਾਂ ਨੂੰ ਘਟਾਉਂਦੀਆਂ ਹਨ। ਇੱਕ ਸੁੰਦਰ ਲਾਈਨ ਕਈ ਵੱਡੇ ਬਫਰਾਂ ਨੂੰ ਆਰਡਰ ਕਰ ਸਕਦੀ ਹੈ। ਪਾਈਥਨ ਸਪੀਡ ਵੀ ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਉਜਾਗਰ ਕਰਦੀ ਹੈ।

3:47 ਐਲੋਕੇਟਰ ਤੁਹਾਡੇ ਸੁਹਜ ਪ੍ਰਤੀ ਅਸਧਾਰਨ ਤੌਰ 'ਤੇ ਉਦਾਸੀਨ ਹੈ। ਤੁਸੀਂ ਲੂਪ ਸਿੰਟੈਕਸ ਨੂੰ ਵੀ ਰੱਖ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਬਦਲ ਸਕਦੇ ਹੋ। ਨੰਬਾ ਸਮਰਥਿਤ ਸੰਖਿਆਤਮਕ ਪਾਈਥਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਨੇਟਿਵ ਕੋਡ ਵਿੱਚ ਕੰਪਾਇਲ ਕਰ ਸਕਦਾ ਹੈ। ਇੱਥੇ ਸਾਡੇ ਟੈਸਟ ਤੋਂ ਇਸਦੇ ਕੰਪਾਈਲਰ ਡੇਕੋਰੇਟਰ ਦੇ ਨਾਲ ਲੂਪ ਹੈ। ਇਹ ਅਜੇ ਵੀ for ਕਹਿੰਦਾ ਹੈ।

### ਕੀ ਇੱਕ ਕੰਪਾਇਲ ਕੀਤਾ ਪਾਈਥਨ ਲੂਪ ਵੀ ਤੇਜ਼ ਹੋ ਸਕਦਾ ਹੈ?

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

4:22 ਨੇਟਿਵ ਐਰੇ ਓਪਰੇਸ਼ਨ ਉਦੋਂ ਮਦਦ ਕਰਦੇ ਹਨ ਜਦੋਂ ਗਣਨਾ ਅਤੇ ਡੇਟਾ ਫਿੱਟ ਹੁੰਦੇ ਹਨ। ਉਸ ਨਤੀਜੇ ਨੂੰ ਮਾਪੋ ਜਿਸਦੀ ਤੁਹਾਡੇ ਕਾਲਰ ਨੂੰ ਅਸਲ ਵਿੱਚ ਲੋੜ ਹੈ। ਹੁਣ ਉਸ ਸ਼ਾਰਟਕੱਟ ਲਈ। ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਪਾਈਥਨ ਫੰਕਸ਼ਨ ਹੈ ਅਤੇ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਇਹ ਇੱਕ ਐਰੇ ਨੂੰ ਸਵੀਕਾਰ ਕਰੇ। ਵੈਕਟਰਾਇਜ਼ ਨਾਮ ਦਾ ਇੱਕ ਰੈਪਰ ਗੁੰਮ ਹੋਏ ਪ੍ਰਦਰਸ਼ਨ ਬਟਨ ਵਰਗਾ ਲੱਗਦਾ ਹੈ। ਇਸਦੇ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਵਾਕ ਦੀ ਉਡੀਕ ਹੈ। ਨੰਪਾਈ ਕਹਿੰਦਾ ਹੈ ਕਿ ਇਸਦਾ ਵੈਕਟਰਾਇਜ਼ ਰੈਪਰ ਮੁੱਖ ਤੌਰ 'ਤੇ ਸੁਵਿਧਾ ਲਈ ਪ੍ਰਦਾਨ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਸਦਾ ਲਾਗੂਕਰਨ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਇੱਕ for ਲੂਪ ਹੈ।

4:43 ਰੈਪਰ ਬੈਚਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ, ਪਰ ਲਗਾਤਾਰ ਤੱਤਾਂ ਲਈ ਤੁਹਾਡੇ ਪਾਈਥਨ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਦਾ ਰਹਿੰਦਾ ਹੈ। ਇੰਟਰਫੇਸ ਛੋਟਾ ਹੋ ਗਿਆ। ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸੀਮਾ ਰੁੱਝੀ ਰਹੀ। ਉਹੀ ਮੁੱਲਾਂ ਨੂੰ ਪਾਈਥਨ ਕਾਲਬੈਕ ਰਾਹੀਂ ਵਾਪਸ ਆਉਂਦੇ ਵੇਖੋ। ਤਿਆਰ ਐਰੇ ਦੇ ਨਾਲ, ਇਸ ਸੰਸਕਰਣ ਵਿੱਚ ਲਗਭਗ ਸਤਾਸੀ ਮਿਲੀਸਕਿੰਟ ਲੱਗੇ। ਇਹ ਸਾਡੀ ਸਮਝ ਨਾਲੋਂ ਹੌਲੀ ਸੀ।

### np.vectorize ਅਸਲ ਵਿੱਚ ਕੀ ਚਲਾਉਂਦਾ ਹੈ?

4:56 ਇੱਕ ਉਪਯੋਗੀ ਪ੍ਰਸਾਰਣ ਰੈਪਰ ਉਸ ਸਹੀ ਪ੍ਰਤੀ-ਤੱਤ ਕੰਮ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖ ਸਕਦਾ ਹੈ ਜਿਸਨੂੰ ਤੁਸੀਂ ਹਟਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਸੀ। ਇੱਕ ਬੈਚ ਇੰਟਰਫੇਸ ਦੇ ਪਿੱਛੇ ਲਾਗੂਕਰਨ ਦੀ ਜਾਂਚ ਕਰੋ, ਅਨੁਕੂਲ ਡੇਟਾ ਨੂੰ ਉਸਦੇ ਉਪਯੋਗੀ ਰੂਪ ਵਿੱਚ ਰੱਖੋ, ਅਤੇ ਤੁਲਨਾ ਵਿੱਚ ਪਰਿਵਰਤਨ ਨੂੰ ਸ਼ਾਮਲ ਕਰੋ। ਨੇਟਿਵ, ਕਾਲਬੈਕ ਅਤੇ ਕੰਪਾਇਲ ਕੀਤੇ ਲੂਪਸ ਕਾਲਰ ਦੀ ਕੁਰਸੀ ਤੋਂ ਇੱਕੋ ਜਿਹੇ ਦਿਖਾਈ ਦੇ ਸਕਦੇ ਹਨ। ਵੈਕਟਰਾਇਜ਼ ਨਾਮ ਨੇ ਇੱਕ ਵਾਅਦਾ ਕੀਤਾ ਜੋ ਤੁਹਾਡੇ ਸਟਾਪਵਾਚ ਨੇ ਕਦੇ ਸਾਈਨ ਨਹੀਂ ਕੀਤਾ। ਇਸਨੂੰ ਰੱਖੋ ਜਦੋਂ ਸੁਵਿਧਾ ਹੀ ਤੁਹਾਨੂੰ ਚਾਹੀਦੀ ਹੈ। ਪ੍ਰਦਰਸ਼ਨ ਲਈ, ਚੱਲ ਰਹੇ ਲੂਪ ਦੀ ਜਾਂਚ ਕਰੋ। ਮੇਰਾ ਫੈਸਲਾ ਇੱਕ ਮਾਪੇ ਗਏ ਸੰਖਿਆਤਮਕ ਹੌਟ ਪਾਥ ਨੂੰ ਬੈਚ ਕਰਨ ਲਈ SHIP IT ਹੈ।

5:18 ਆਮ ਲੂਪਸ ਨੂੰ ਉਦੋਂ ਰੱਖੋ ਜਦੋਂ ਉਹ ਪਹਿਲਾਂ ਹੀ ਵਧੀਆ ਕੰਮ ਕਰਦੇ ਹਨ। ਜਾਂਚ ਕਰੋ ਕਿ ਕੰਮ ਕਿੱਥੇ ਹੁੰਦਾ ਹੈ ਅਤੇ ਅਗਲੇ ਕਾਲਰ ਨੂੰ ਕੀ ਲੋੜ ਹੈ। ਸਬਸਕ੍ਰਾਈਬ ਕਰੋ, ਘੰਟੀ ਦਬਾਓ, ਅਤੇ ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਮੈਨੂੰ ਦੱਸੋ ਕਿ ਕੀ ਤੁਸੀਂ ਇਸਨੂੰ ਵੱਖਰੇ ਢੰਗ ਨਾਲ ਸਟੈਂਪ ਕੀਤਾ ਹੋਵੇਗਾ। ਅਤੇ ਇਹ ਅੱਜ ਲਈ diff ਹੈ। ਮੈਂ Axrisi ਤੋਂ ਨਿਕੋ ਹਾਂ। ਜ਼ਿੰਮੇਵਾਰੀ ਨਾਲ ਮਰਜ ਕਰੋ। ਮੇਰਾ ਫੈਸਲਾ ਇੱਕ ਮਾਪੇ ਗਏ ਸੰਖਿਆਤਮਕ ਹੌਟ ਪਾਥ ਨੂੰ ਬੈਚ ਕਰਨ ਲਈ SHIP IT ਹੈ। ਆਮ ਲੂਪਸ ਨੂੰ ਉਦੋਂ ਰੱਖੋ ਜਦੋਂ ਉਹ ਪਹਿਲਾਂ ਹੀ ਵਧੀਆ ਕੰਮ ਕਰਦੇ ਹਨ।

### ਤੁਹਾਨੂੰ ਆਪਣੇ ਕੋਡ ਵਿੱਚ ਕੀ ਬਦਲਣਾ ਚਾਹੀਦਾ ਹੈ?

5:41 ਜਾਂਚ ਕਰੋ ਕਿ ਕੰਮ ਕਿੱਥੇ ਹੁੰਦਾ ਹੈ ਅਤੇ ਅਗਲੇ ਕਾਲਰ ਨੂੰ ਕੀ ਲੋੜ ਹੈ। ਸਬਸਕ੍ਰਾਈਬ ਕਰੋ, ਘੰਟੀ ਦਬਾਓ, ਅਤੇ ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਮੈਨੂੰ ਦੱਸੋ ਕਿ ਕੀ ਤੁਸੀਂ ਇਸਨੂੰ ਵੱਖਰੇ ਢੰਗ ਨਾਲ ਸਟੈਂਪ ਕੀਤਾ ਹੋਵੇਗਾ। ਅਤੇ ਇਹ ਅੱਜ ਲਈ diff ਹੈ। ਮੈਂ Axrisi ਤੋਂ ਨਿਕੋ ਹਾਂ। ਜ਼ਿੰਮੇਵਾਰੀ ਨਾਲ ਮਰਜ ਕਰੋ। ਮੇਰਾ ਫੈਸਲਾ ਇੱਕ ਮਾਪੇ ਗਏ ਸੰਖਿਆਤਮਕ ਹੌਟ ਪਾਥ ਨੂੰ ਬੈਚ ਕਰਨ ਲਈ SHIP IT ਹੈ। ਆਮ ਲੂਪਸ ਨੂੰ ਉਦੋਂ ਰੱਖੋ ਜਦੋਂ ਉਹ ਪਹਿਲਾਂ ਹੀ ਵਧੀਆ ਕੰਮ ਕਰਦੇ ਹਨ।

## ਸਰੋਤ

- [Universal functions (ufunc) basics — NumPy 2.2](https://numpy.org/doc/2.2/user/basics.ufuncs.html) — NumPy
- [The N-dimensional array — NumPy 2.2](https://numpy.org/doc/2.2/reference/arrays.ndarray.html) — NumPy
- [numpy.vectorize — convenience and performance notes](https://numpy.org/doc/2.2/reference/generated/numpy.vectorize.html) — NumPy
- [CPU/SIMD optimizations — NumPy 2.2](https://numpy.org/doc/2.2/reference/simd/index.html) — NumPy
- [dis — Disassembler for Python bytecode](https://docs.python.org/3.10/library/dis.html) — Python Software Foundation
- [CPython 3.10.12 list representation](https://github.com/python/cpython/blob/v3.10.12/Include/cpython/listobject.h) — CPython contributors
- [The limits of Python vectorization as a performance technique](https://pythonspeed.com/articles/vectorization-python-alternatives/) — Itamar Turner-Trauring / Python⇒Speed
- [Performance Tips](https://numba.readthedocs.io/en/stable/user/performance-tips.html) — Numba
- [Basics of CuPy](https://docs.cupy.dev/en/stable/user_guide/basic.html) — CuPy