ਲਾਭ:
- ਏਆਈ-ਪਾਵਰਡ ਪਾਈਥਨ ਕੋਡ ਨਾਲ ਇੰਜਨੀਅਰਿੰਗ ਗਣਨਾ, ਯੂਨਿਟ ਪ੍ਰਬੰਧਨ ਅਤੇ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਸਵੈਚਾਲਤ ਕਰਨ ਦੀ ਸਮਰੱਥਾ
- ਯੂਨਿਟ ਚੈਕਿੰਗ, ਜਾਣੇ-ਪਛਾਣੇ ਨਤੀਜੇ ਟੈਸਟਿੰਗ, ਅਤੇ ਕਿਨਾਰੇ ਦੇ ਕੇਸਾਂ ਨਾਲ AI ਕੋਡ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਦੀ ਸਮਰੱਥਾ
- ਦੁਹਰਾਉਣ ਯੋਗ, ਟਰੇਸ ਕਰਨ ਯੋਗ ਅਤੇ ਸੰਸਕਰਣ-ਨਿਯੰਤਰਿਤ ਖਾਤਾ ਦਸਤਾਵੇਜ਼ ਤਿਆਰ ਕਰਨ ਦੀ ਆਦਤ ਪਾਉਣ ਦੀ ਸਮਰੱਥਾ
ਮਕੈਨੀਕਲ ਇੰਜਨੀਅਰਿੰਗ ਵਿੱਚ, ਉਹੀ ਗਣਨਾ ਵਾਰ-ਵਾਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ: ਹਿੱਸਿਆਂ ਦੇ ਇੱਕ ਪਰਿਵਾਰ ਦੇ ਤਣਾਅ, ਸੰਚਾਲਨ ਬਿੰਦੂਆਂ ਦੀ ਇੱਕ ਰੇਂਜ ਲਈ ਪੰਪ ਪਾਵਰ, ਵੱਖ-ਵੱਖ ਤਾਪਮਾਨਾਂ 'ਤੇ ਜਾਇਦਾਦ ਟੇਬਲ। ਇਹਨਾਂ ਨੂੰ ਹੱਥੀਂ ਕਰਨਾ ਹੌਲੀ ਅਤੇ ਗਲਤੀ-ਸੰਭਾਵੀ ਹੈ। ਪਾਈਥਨ (ਇੰਜੀਨੀਅਰਿੰਗ ਲਈ ਅਮੀਰ ਲਾਇਬ੍ਰੇਰੀਆਂ ਵਾਲੀ ਇੱਕ ਆਸਾਨ-ਸਿੱਖਣ ਵਾਲੀ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾ) ਇਹਨਾਂ ਦੁਹਰਾਅ ਨੂੰ ਸਵੈਚਾਲਤ ਕਰਦਾ ਹੈ; ਇਹ ਖਾਤੇ ਨੂੰ ਦੁਹਰਾਉਣ ਯੋਗ, ਖੋਜਣਯੋਗ ਅਤੇ ਸੰਸਕਰਣ ਨਿਯੰਤਰਿਤ ਬਣਾਉਂਦਾ ਹੈ। ਆਰਟੀਫੀਸ਼ੀਅਲ ਇੰਟੈਲੀਜੈਂਸ (AI) ਪਾਈਥਨ ਕੋਡ ਬਣਾਉਣ ਵਿੱਚ ਬਹੁਤ ਤੇਜ਼ ਹੈ: ਇੱਕ ਫਾਰਮੂਲੇ ਨੂੰ ਇੱਕ ਫੰਕਸ਼ਨ ਵਿੱਚ ਬਦਲਣਾ, ਯੂਨਿਟ ਪ੍ਰਬੰਧਨ ਜੋੜਨਾ, ਡੇਟਾ ਪੜ੍ਹਨਾ, ਗ੍ਰਾਫਾਂ ਦੀ ਸਾਜ਼ਿਸ਼ ਕਰਨਾ। ਪਰ ਇੱਥੇ ਇੱਕ ਖ਼ਤਰਨਾਕ ਗਲਤ ਧਾਰਨਾ ਹੈ: ਕਿਉਂਕਿ ਕੋਡ ਗਲਤੀਆਂ ਤੋਂ ਬਿਨਾਂ ਕੰਮ ਕਰਦਾ ਹੈ ਇਸਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਹੈ ਕਿ ਇਹ ਸਹੀ ਢੰਗ ਨਾਲ ਗਣਨਾ ਕਰਦਾ ਹੈ। ਏਆਈ ਕੋਡ ਗਲਤ ਯੂਨਿਟ ਪਰਿਵਰਤਨ, ਗਲਤ ਫਾਰਮੂਲੇ, ਜਾਂ ਕਿਨਾਰੇ ਦੇ ਮਾਮਲਿਆਂ ਵਿੱਚ ਚੁੱਪਚਾਪ ਗਲਤ ਨਤੀਜੇ ਵਾਪਸ ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ ਪ੍ਰੋਗਰਾਮ ਬਿਨਾਂ ਕਿਸੇ ਤਰੁੱਟੀ ਦੇ ਚੱਲਦਾ ਰਹੇਗਾ। ਇਹੀ ਕਾਰਨ ਹੈ ਕਿ ਹਰ ਇੰਜੀਨੀਅਰਿੰਗ ਕੋਡ AI ਨਾਲ ਪੈਦਾ ਹੁੰਦਾ ਹੈ; ਜਾਣੇ-ਪਛਾਣੇ ਨਤੀਜਿਆਂ ਵਾਲੇ ਟੈਸਟ ਇਨਪੁਟਸ ਯੂਨਿਟ (ਆਕਾਰ) ਦੀ ਜਾਂਚ ਅਤੇ ਕਿਨਾਰੇ ਕੇਸ ਟਰਾਇਲਾਂ ਦੁਆਰਾ ਤਸਦੀਕ ਕੀਤੇ ਬਿਨਾਂ ਭਰੋਸੇਯੋਗ ਨਹੀਂ ਹਨ। ਇਸ ਯੂਨਿਟ ਵਿੱਚ, ਤੁਸੀਂ ਸਿੱਖੋਗੇ ਕਿ ਕਿਵੇਂ AI ਨਾਲ Python ਖਾਤਾ ਆਟੋਮੇਸ਼ਨ ਨੂੰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਸੈਟ ਅਪ ਕਰਨਾ ਹੈ।
ਕੋਡ ਖਾਤਾ ਕਿਉਂ? ਟਰੇਸੇਬਿਲਟੀ ਅਤੇ ਪ੍ਰਜਨਨਯੋਗਤਾ
ਇੱਕ ਦਸਤੀ ਗਣਨਾ ਇੱਕ-ਬੰਦ ਹੈ; ਜਦੋਂ ਕੋਈ ਇਨਪੁਟ ਬਦਲਦਾ ਹੈ, ਤਾਂ ਇਹ ਸਕ੍ਰੈਚ ਤੋਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਵਿਚਕਾਰਲੇ ਪੜਾਅ ਖਤਮ ਹੋ ਜਾਂਦੇ ਹਨ। ਕੋਡ ਵਿੱਚ ਕੀਤੀ ਗਈ ਗਣਨਾ ਇੱਕ ਦਸਤਾਵੇਜ਼ ਦੀ ਤਰ੍ਹਾਂ ਹੈ: ਇਨਪੁਟਸ, ਫਾਰਮੂਲੇ ਅਤੇ ਆਉਟਪੁੱਟ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਲਿਖੇ ਗਏ ਹਨ; ਤੁਸੀਂ ਇੱਕ ਇੰਪੁੱਟ ਬਦਲਦੇ ਹੋ ਅਤੇ ਸਕਿੰਟਾਂ ਦੇ ਅੰਦਰ ਇੱਕ ਨਵਾਂ ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹੋ; ਸੰਸਕਰਣ ਨਿਯੰਤਰਣ (ਜਿਵੇਂ ਕਿ ਗਿੱਟ) ਦੇ ਨਾਲ, "ਮੈਂ ਕਿਹੜੀ ਮਿਤੀ ਨੂੰ ਕਿਸ ਮੁੱਲ ਨਾਲ ਗਿਣਿਆ ਹੈ" ਨੂੰ ਟਰੈਕ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ ਨਿਯੰਤਰਣ ਅਤੇ ਜਵਾਬਦੇਹੀ ਦੇ ਰੂਪ ਵਿੱਚ ਅਨਮੋਲ ਹੈ. ਪਰ ਇਹ ਸ਼ਕਤੀ ਕੋਡ ਦੀ ਸ਼ੁੱਧਤਾ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ; ਇੱਕ ਗਲਤ ਕੋਡ ਗਲਤ ਨਤੀਜਾ ਪੈਦਾ ਕਰਦਾ ਹੈ, ਪ੍ਰਜਨਨ ਅਤੇ ਤੇਜ਼ੀ ਨਾਲ ਵੀ।
ਸੰਕੇਤ: ਹਰੇਕ ਗਣਨਾ ਫੰਕਸ਼ਨ ਲਈ ਇਸਦੇ ਅੱਗੇ ਇੱਕ ਜਾਣੇ-ਪਛਾਣੇ ਸਹੀ ਨਤੀਜੇ ਦੇ ਨਾਲ ਇੱਕ ਟੈਸਟ ਲਿਖੋ (ਪਾਈਥਨ ਵਿੱਚ ਦਾਅਵਾ ਕਰੋ)। ਉਦਾਹਰਨ ਲਈ, ਤੁਹਾਡੇ ਤਣਾਅ ਫੰਕਸ਼ਨ ਨੂੰ ਇੱਕ ਜਾਣੇ-ਪਛਾਣੇ ਨਮੂਨੇ ਵਿੱਚ 28.1 MPa ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਟੈਸਟ ਤੁਹਾਨੂੰ ਤੁਰੰਤ ਚੇਤਾਵਨੀ ਦਿੰਦਾ ਹੈ ਜੇਕਰ ਤੁਸੀਂ ਭਵਿੱਖ ਵਿੱਚ ਕੋਡ ਬਦਲਦੇ ਸਮੇਂ ਕੁਝ ਤੋੜਦੇ ਹੋ। ਇੰਜਨੀਅਰਿੰਗ ਕੋਡ ਜਿਸ ਦੀ ਜਾਂਚ ਨਹੀਂ ਕੀਤੀ ਗਈ ਹੈ, ਇੱਕ ਗੈਰ-ਪ੍ਰਮਾਣਿਤ ਖਾਤਾ ਹੈ।
ਵਾਲੀਅਮ ਪ੍ਰਬੰਧਨ: ਗਲਤੀ ਦਾ ਸਭ ਤੋਂ ਆਮ ਸਰੋਤ
ਇੰਜਨੀਅਰਿੰਗ ਕੋਡ ਵਿੱਚ, ਜ਼ਿਆਦਾਤਰ ਤਰੁੱਟੀਆਂ ਯੂਨਿਟਾਂ ਤੋਂ ਆਉਂਦੀਆਂ ਹਨ: kN ਨਾਲ N, mm ਨਾਲ m, MPa ਨਾਲ Pa, ਜੋ ਕਿ 1000 ਜਾਂ 1,000,000 ਦੇ ਫੈਕਟਰ ਦੁਆਰਾ ਉਲਝਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਦੋ ਬਚਾਅ ਹਨ. ਪਹਿਲਾ ਅਨੁਸ਼ਾਸਨ ਹੈ: ਸ਼ੁਰੂ ਤੋਂ ਇੱਕ ਸਿੰਗਲ ਯੂਨਿਟ ਸਿਸਟਮ ਚੁਣਨਾ (ਜਿਵੇਂ ਕਿ N, mm, MPa) ਅਤੇ ਸਾਰੇ ਇਨਪੁਟਸ ਨੂੰ ਇਸ ਵਿੱਚ ਬਦਲਣਾ ਅਤੇ ਵੇਰੀਏਬਲ ਨਾਮਾਂ (ਲੰਬਾਈ_mm, ਫੋਰਸ_N) ਵਿੱਚ ਯੂਨਿਟ ਜੋੜਨਾ। ਦੂਜਾ ਟੂਲ ਹੈ: ਪਿੰਟ ਵਰਗੀ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਕੋਡ ਦੇ ਅੰਦਰ ਯੂਨਿਟਾਂ ਨੂੰ ਰੱਖਦੀ ਹੈ ਅਤੇ ਅਸੰਗਤ ਕਾਰਵਾਈ ਨੂੰ ਇੱਕ ਗਲਤੀ ਵਜੋਂ ਫੜਦੀ ਹੈ।
ਪਹੁੰਚ
ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ
ਫਾਇਦਾ
ਨਾਮਕਰਨ ਅਨੁਸ਼ਾਸਨ
ਜਿਵੇਂ force_N, length_mm
ਸਧਾਰਨ, ਕੋਈ ਨਿਰਭਰਤਾ ਨਹੀਂ
ਸਿੰਗਲ ਯੂਨਿਟ ਸਿਸਟਮ
ਸਭ ਨੂੰ N-mm-MPa ਵਿੱਚ ਬਦਲਿਆ ਗਿਆ
ਸਾਦਗੀ, ਗਤੀ
ਪਿੰਟ ਲਾਇਬ੍ਰੇਰੀ
ਵੇਰੀਏਬਲ ਦੁਆਰਾ ਯੂਨਿਟ ਨੂੰ ਮੂਵ ਕਰਦਾ ਹੈ
ਆਟੋਮੈਟਿਕਲੀ ਅਸੰਗਤਤਾ ਫੜਦਾ ਹੈ
ਜਾਣਿਆ ਨਤੀਜਾ ਟੈਸਟ
ਦਾਅਵੇ ਦੇ ਨਾਲ ਹਵਾਲਾ
ਫਾਰਮੂਲਾ/ਯੂਨਿਟ ਗਲਤੀ ਫੜਦਾ ਹੈ
ਸਾਵਧਾਨ: ਏਆਈ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਵਿੱਚ ਇੱਕ ਯੂਨਿਟ ਰੂਪਾਂਤਰਣ ਗੁੰਮ ਜਾਂ ਗਲਤ ਹੋ ਸਕਦਾ ਹੈ ਅਤੇ ਕੋਡ ਅਜੇ ਵੀ "ਕੰਮ" ਕਰੇਗਾ। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਵਿਆਸ ਮਿਲੀਮੀਟਰ ਹੈ ਅਤੇ ਖੇਤਰ m² ਹੋਣ ਦੀ ਉਮੀਦ ਹੈ, ਤਾਂ ਨਤੀਜਾ 1,000,000 ਗੁਣਾ ਘਟ ਜਾਵੇਗਾ, ਪਰ ਪ੍ਰੋਗਰਾਮ ਕੋਈ ਗਲਤੀ ਨਹੀਂ ਦੇਵੇਗਾ। ਕੋਡ ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ, ਇਨਪੁਟਸ ਅਤੇ ਆਉਟਪੁੱਟ ਦੀਆਂ ਇਕਾਈਆਂ ਬਾਰੇ ਟਿੱਪਣੀ ਕਰੋ; ਫਿਰ ਇੱਕ ਜਾਣੀ-ਪਛਾਣੀ ਉਦਾਹਰਨ ਦੇ ਨਾਲ ਨਤੀਜਾ ਪ੍ਰਦਾਨ ਕਰੋ।
ਕਦਮ ਦਰ ਕਦਮ: AI ਪ੍ਰਮਾਣਿਤ ਖਾਤਾ ਕੋਡ
- ਸਮੱਸਿਆ ਅਤੇ ਯੂਨਿਟ ਸਿਸਟਮ ਨੂੰ ਸਪੱਸ਼ਟ ਕਰੋ। ਇਨਪੁਟਸ, ਆਉਟਪੁੱਟ, ਇਕਾਈਆਂ।
- ਫੰਕਸ਼ਨ ਤਿਆਰ ਕਰੋ। ਸਿੰਗਲ ਜ਼ਿੰਮੇਵਾਰ, ਵਿਆਖਿਆਤਮਕ, ਸੰਯੁਕਤ।
- ਜਾਣੇ-ਪਛਾਣੇ ਨਤੀਜੇ ਟੈਸਟ ਸ਼ਾਮਲ ਕਰੋ। ਹਵਾਲਾ ਉਦਾਹਰਨ ਦੇ ਨਾਲ ਦਾਅਵਾ ਕਰੋ।
- ਕਿਨਾਰੇ ਦੇ ਕੇਸਾਂ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ। ਜ਼ੀਰੋ, ਨੈਗੇਟਿਵ, ਬਹੁਤ ਵੱਡਾ/ਛੋਟਾ ਇੰਪੁੱਟ।
- ਯੂਨਿਟ ਦੀ ਜਾਂਚ ਕਰੋ। ਕੀ ਆਉਟਪੁੱਟ ਦੀ ਇਕਾਈ ਉਮੀਦ ਅਨੁਸਾਰ ਮੇਲ ਖਾਂਦੀ ਹੈ?
- ਦਸਤਾਵੇਜ਼ ਅਤੇ ਸੰਸਕਰਣ। ਧਾਰਨਾਵਾਂ, ਸਰੋਤ, ਮਿਤੀ; git ਨਾਲ ਖੋਜਣਯੋਗਤਾ.
ਪ੍ਰੋਂਪਟ ਜੋ ਫੰਕਸ਼ਨ ਅਤੇ ਟੈਸਟ ਬਣਾਉਂਦਾ ਹੈ
ਭੂਮਿਕਾ: ਅਨੁਭਵੀ ਪਾਈਥਨ ਡਿਵੈਲਪਰ ਇੰਜੀਨੀਅਰਿੰਗ ਗਣਨਾਵਾਂ ਲਿਖ ਰਿਹਾ ਹੈ। ਟਾਸਕ: ਇੱਕ ਫੰਕਸ਼ਨ ਲਿਖੋ ਜੋ ਇੱਕ ਆਇਤਾਕਾਰ ਕਰਾਸ-ਸੈਕਸ਼ਨ ਕੰਟੀਲੀਵਰ ਬੀਮ ਵਿੱਚ ਵੱਧ ਤੋਂ ਵੱਧ ਝੁਕਣ ਵਾਲੇ ਤਣਾਅ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ। ਇੰਪੁੱਟ: F (N), L (mm), b (mm), h (mm)। ਆਉਟਪੁੱਟ: ਸਿਗਮਾ (MPa)। ਸੰਮੇਲਨ: ਯੂਨਿਟ ਸਿਸਟਮ N-mm-MPa; ਹਰੇਕ ਐਂਟਰੀ ਦੀ ਇਕਾਈ ਨੂੰ ਟਿੱਪਣੀ ਕਰੋ। ਨਿਯਮ: I = b*h^3/12 ਅਤੇ ਸਿਗਮਾ = M*c/I ਦੀ ਵਰਤੋਂ ਕਰੋ; ਕਦਮਾਂ 'ਤੇ ਟਿੱਪਣੀ ਕਰੋ। ਨਿਯਮ: ਜਾਣੇ-ਪਛਾਣੇ ਨਤੀਜੇ ਦੇ ਨਾਲ ਇੱਕ ਟੈਸਟ ਸ਼ਾਮਲ ਕਰੋ: F=500,L=300,b=20,h=40 ਲਈ ਸਿਗਮਾ ~28.1 MPa; ਜ਼ੋਰ ਨਾਲ ਜਾਂਚ ਕਰੋ (ਛੋਟੀ ਸਹਿਣਸ਼ੀਲਤਾ)।
ਕਿਨਾਰੇ ਸਥਿਤੀ ਪ੍ਰੋਂਪਟ
ਉਪਰੋਕਤ ਫੰਕਸ਼ਨ ਵਿੱਚ ਕਿਨਾਰੇ ਦੇ ਕੇਸਾਂ ਦੀ ਜਾਂਚ ਸ਼ਾਮਲ ਕਰੋ:- ਜੇਕਰ b, h ਜਾਂ L ਜ਼ੀਰੋ ਜਾਂ ਨੈਗੇਟਿਵ ਹਨ, ਤਾਂ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਗਲਤੀ ਦਿਓ (ਮੁੱਲ ਐਰਰ ਵਧਾਓ)।- ਟਿੱਪਣੀ ਕਰੋ ਜੇਕਰ ਬਹੁਤ ਵੱਡੇ/ਛੋਟੇ ਇਨਪੁਟਸ ਦੇ ਨਾਲ ਓਵਰਫਲੋ/ਸ਼ੁੱਧਤਾ ਸਮੱਸਿਆ ਹੈ। ਨਾਲ ਹੀ 3 ਹੋਰ ਵੱਖ-ਵੱਖ ਟੈਸਟ ਇਨਪੁਟਸ ਸ਼ਾਮਲ ਕਰੋ ਅਤੇ ਸੰਭਾਵਿਤ ਨਤੀਜਾ ਲਿਖੋ; ਨਤੀਜਿਆਂ ਦੀ ਵਿਆਖਿਆ ਇਸ ਤਰੀਕੇ ਨਾਲ ਕਰੋ ਕਿ ਮੈਂ ਉਹਨਾਂ ਨੂੰ ਹੱਥੀਂ ਤਸਦੀਕ ਕਰ ਸਕਾਂ।
ਯੂਨਿਟ ਸੁਰੱਖਿਆ (ਪਿੰਟ) ਪ੍ਰੋਂਪਟ
'ਪਿੰਟ' ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਨਾਲ ਇੱਕੋ ਖਾਤੇ ਨੂੰ ਯੂਨਿਟ-ਸੁਰੱਖਿਅਤ ਕਰੋ। ਇਨਪੁਟਸ ਨੂੰ ਯੂਨਿਟਾਂ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦਿਓ (ਜਿਵੇਂ ਕਿ 500 * ureg.newton)। ਆਉਟਪੁੱਟ ਨੂੰ MPa ਵਿੱਚ ਬਦਲੋ ਅਤੇ ਇਸਨੂੰ ਪ੍ਰਿੰਟ ਕਰੋ। ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਉਦਾਹਰਣ ਸ਼ਾਮਲ ਕਰੋ ਜੋ ਦਿਖਾਉਂਦੀ ਹੈ ਕਿ ਗਲਤ ਯੂਨਿਟ ਦੇ ਨਾਲ ਇੱਕ ਇਨਪੁਟ ਦਿੱਤੇ ਜਾਣ 'ਤੇ ਪਿੰਟ ਕਿਵੇਂ ਅਸਫਲ ਹੁੰਦਾ ਹੈ।
ਕੋਡ ਚੈੱਕ ਪ੍ਰੋਂਪਟ
ਕੋਡ ਸਮੀਖਿਆ ਦੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ ਹੇਠਾਂ ਮੇਰੇ ਇੰਜੀਨੀਅਰਿੰਗ ਗਣਨਾ ਕੋਡ ਦੀ ਆਲੋਚਨਾ ਕਰੋ, ਮੇਰੇ ਨਾਲ ਸਹਿਮਤ ਨਾ ਹੋਵੋ। ਖਾਸ ਤੌਰ 'ਤੇ: ਕੀ ਯੂਨਿਟ ਪਰਿਵਰਤਨ ਸਹੀ ਹੈ, ਕੀ ਫਾਰਮੂਲਾ ਸਹੀ ਹੈ, ਕੀ ਕਿਨਾਰੇ ਦੇ ਕੇਸਾਂ (ਜ਼ੀਰੋ, ਨੈਗੇਟਿਵ) 'ਤੇ ਵਿਚਾਰ ਕੀਤਾ ਗਿਆ ਹੈ, ਕੀ ਟੈਸਟ ਸੱਚਮੁੱਚ ਪੁਸ਼ਟੀ ਕਰਨ ਵਾਲੇ ਹਨ? ਹਰੇਕ ਖੋਜ ਲਈ, ਲਿਖੋ ਕਿ ਇਸਨੂੰ ਕਿਵੇਂ ਠੀਕ ਕਰਨਾ ਹੈ।[ਕੋਡ]
ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ / ਮਜ਼ਬੂਤ ਪ੍ਰੋਂਪਟ
ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ:
ਤਣਾਅ ਦੀ ਗਣਨਾ ਲਈ ਪਾਈਥਨ ਕੋਡ ਲਿਖੋ।
ਇਕਾਈਆਂ, ਫਾਰਮੂਲੇ, ਇਨਪੁਟ ਪਰਿਭਾਸ਼ਾਵਾਂ ਅਤੇ ਟੈਸਟਾਂ ਦੀ ਕੋਈ ਚੋਣ ਨਹੀਂ; AI ਉਹ ਕੋਡ ਤਿਆਰ ਕਰਦਾ ਹੈ ਜੋ ਕੰਮ ਕਰਦਾ ਹੈ ਪਰ ਅਸਪਸ਼ਟ ਹੈ ਅਤੇ ਜਿਸਦੀ ਇਕਾਈ ਅਣਜਾਣ ਹੈ।
ਸ਼ਕਤੀਸ਼ਾਲੀ ਪ੍ਰਾਉਟ:
ਕੰਟੀਲੀਵਰ ਬੀਮ ਵਿੱਚ ਝੁਕਣ ਵਾਲੇ ਤਣਾਅ ਫੰਕਸ਼ਨ ਨੂੰ ਲਿਖੋ। ਇੰਪੁੱਟ F(N), L(mm), b(mm), h(mm); ਆਉਟਪੁੱਟ ਸਿਗਮਾ (MPa) N-mm-MPa ਸਿਸਟਮ, ਟਿੱਪਣੀ ਵਿੱਚ ਹਰੇਕ ਇਕਾਈ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰੋ। ਜਾਣੇ-ਪਛਾਣੇ ਨਤੀਜਿਆਂ ਨਾਲ ਇੱਕ ਟੈਸਟ ਸ਼ਾਮਲ ਕਰੋ (F=500, L=300, b=20, h=40 → ~28.1 MPa, assert)। ਜ਼ੀਰੋ/ਨੈਗੇਟਿਵ ਇਨਪੁਟ 'ਤੇ ਗਲਤੀ ਦਿਓ। ਕਿਨਾਰੇ ਦੇ ਕੇਸਾਂ ਦੀ ਵਿਆਖਿਆ ਕਰੋ।
ਦੂਜੇ ਪ੍ਰੋਂਪਟ ਲਈ ਯੂਨਿਟ ਸਿਸਟਮ, ਫਾਰਮੂਲਾ, ਇਨਪੁਟਸ, ਟੈਸਟ, ਅਤੇ ਕਿਨਾਰੇ ਦੇ ਕੇਸਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ; ਇਹ ਕੋਡ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਬਣਾਉਂਦਾ ਹੈ।
ਤਿੰਨ ਮਿੰਨੀ ਕੇਸ (ਨੰਬਰਾਂ ਦੁਆਰਾ)
ਕੇਸ 1 - ਚੁੱਪ ਵੌਲਯੂਮ ਗਲਤੀ। AI ਦੁਆਰਾ ਨਿਰਮਿਤ ਖੇਤਰ ਦੀ ਗਣਨਾ mm ਵਿੱਚ ਵਿਆਸ ਲੈਂਦੀ ਹੈ ਅਤੇ pi*d**2/4 ਦੇ ਨਾਲ mm² ਦਿੰਦੀ ਹੈ, ਪਰ ਅਗਲੀ ਲਾਈਨ ਇਸਨੂੰ ਇੱਕ ਫਾਰਮੂਲੇ ਵਿੱਚ ਰੱਖਦੀ ਹੈ ਜੋ m² ਦੀ ਉਮੀਦ ਕਰਦਾ ਹੈ; ਕੋਡ ਬਿਨਾਂ ਕਿਸੇ ਤਰੁੱਟੀ ਦੇ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਤਣਾਅ ਨੂੰ 1,000,000 ਗੁਣਾ ਘੱਟ ਦਿੰਦਾ ਹੈ। ਜਦੋਂ ਇੰਜੀਨੀਅਰ ਇੱਕ ਜਾਣੇ-ਪਛਾਣੇ ਨਤੀਜੇ (ਅਸਰਟ ਐਬਸ(ਸਿਗਮਾ-28.1)<0.5) ਨਾਲ ਟੈਸਟ ਚਲਾਉਂਦਾ ਹੈ, ਤਾਂ ਟੈਸਟ ਫਟ ਜਾਂਦਾ ਹੈ ਅਤੇ ਗਲਤੀ ਫੜੀ ਜਾਂਦੀ ਹੈ। ਜੇਕਰ ਕੋਈ ਟੈਸਟ ਨਾ ਹੁੰਦਾ, ਤਾਂ ਗਲਤ ਨਤੀਜਾ ਬਿਨਾਂ ਕਿਸੇ ਧਿਆਨ ਦੇ ਰਿਪੋਰਟ ਵਿੱਚ ਦਾਖਲ ਹੁੰਦਾ। ਪਾਠ: ਕਾਰਜਸ਼ੀਲ ਕੋਡ ≠ ਸਹੀ ਕੋਡ।
ਕੇਸ 2 - ਐਜ ਸਟੇਟ ਕਰੈਸ਼। ਕੋਡ ਵਿੱਚ ਜੋ ਇੱਕ ਭਾਗ ਪਰਿਵਾਰ ਲਈ ਲੂਪ ਕਰਦਾ ਹੈ, ਮੋਟਾਈ h=0 ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਦਰਜ ਕੀਤੀ ਜਾਂਦੀ ਹੈ; ਜਦੋਂ I = b*h**3/12 = 0, ਸਿਗਮਾ = M*c/I ਜ਼ੀਰੋ ਗਲਤੀ ਨਾਲ ਵੰਡ ਦਿੰਦਾ ਹੈ। if h<=0 ਲਈ ਧੰਨਵਾਦ: AI ਦੁਆਰਾ ਜੋੜਿਆ ਗਿਆ ValueError ਕੰਟਰੋਲ ਵਧਾਓ, ਕੋਡ ਇੱਕ ਅਰਥਪੂਰਨ ਸੰਦੇਸ਼ ਨਾਲ ਰੁਕ ਜਾਂਦਾ ਹੈ ਅਤੇ ਚੁੱਪਚਾਪ inf ਪੈਦਾ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਪਾਠ: ਕਿਨਾਰੇ ਦੇ ਕੇਸਾਂ ਨੂੰ ਪਹਿਲਾਂ ਹੀ ਸੰਭਾਲੋ।
ਕੇਸ 3 - ਦੁਹਰਾਉਣਯੋਗਤਾ ਲਾਭ। 40 ਵੱਖ-ਵੱਖ ਓਪਰੇਟਿੰਗ ਪੁਆਇੰਟਾਂ ਲਈ ਪੰਪ ਦੀ ਸ਼ਕਤੀ ਦੀ ਖੁਦ ਗਣਨਾ ਕਰਨ ਲਈ ਇੱਕ ਇੰਜੀਨੀਅਰ ਨੂੰ ਅੱਧਾ ਦਿਨ ਲੱਗ ਗਿਆ। AI ਵਿੱਚ ਲਿਖੀ ਗਈ, ਸਕ੍ਰਿਪਟ CSV ਨੂੰ ਪੜ੍ਹਦੀ ਹੈ, ਹਰੇਕ ਲਾਈਨ ਲਈ ਪਾਵਰ ਦੀ ਗਣਨਾ ਕਰਦੀ ਹੈ, ਅਤੇ ਇੱਕ ਜਾਣੇ-ਪਛਾਣੇ ਬਿੰਦੂ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦੀ ਹੈ, ਕੰਮ ਨੂੰ ~2 ਮਿੰਟ ਤੱਕ ਘਟਾਉਂਦੀ ਹੈ ਅਤੇ ਨਤੀਜਿਆਂ ਨੂੰ ਟਰੇਸ ਕਰਨ ਯੋਗ ਫਾਈਲ ਵਿੱਚ ਲਿਖਦੀ ਹੈ। ਜਦੋਂ ਕੋਈ ਐਂਟਰੀ ਬਦਲਦੀ ਹੈ, ਤਾਂ ਸਾਰੀ ਸਾਰਣੀ ਹਰ ਸਕਿੰਟ ਅੱਪਡੇਟ ਹੁੰਦੀ ਹੈ। ਪਾਠ: ਪ੍ਰਮਾਣਿਤ ਆਟੋਮੇਸ਼ਨ ਤੇਜ਼ ਅਤੇ ਭਰੋਸੇਮੰਦ ਹੈ।
ਆਮ ਗਲਤੀਆਂ
- "ਕੰਮ ਕੀਤਾ = ਸਹੀ" ਗਲਤੀ: ਇਹ ਸੋਚਣਾ ਕਿ ਕੋਡ ਜੋ ਗਲਤੀਆਂ ਤੋਂ ਬਿਨਾਂ ਕੰਮ ਕਰਦਾ ਹੈ ਸਹੀ ਹੈ।
- ਟੈਸਟ ਨਹੀਂ ਲਿਖਣਾ: ਕਿਸੇ ਜਾਣੇ-ਪਛਾਣੇ ਨਤੀਜੇ ਦੇ ਨਾਲ ਸੰਦਰਭ ਟੈਸਟ ਦੇ ਬਿਨਾਂ ਕੋਡ 'ਤੇ ਭਰੋਸਾ ਕਰਨਾ।
- ਯੂਨਿਟ ਅਸਪਸ਼ਟਤਾ: ਇਨਪੁਟ/ਆਉਟਪੁੱਟ ਯੂਨਿਟਾਂ ਨੂੰ ਬਿਨਾਂ ਵਿਆਖਿਆ ਦੇ ਛੱਡਣਾ, ਪਰਿਵਰਤਨ ਨੂੰ ਛੱਡਣਾ।
- ਕਿਨਾਰੇ ਦੇ ਮਾਮਲਿਆਂ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨਾ: ਜ਼ੀਰੋ/ਨੈਗੇਟਿਵ ਇਨਪੁਟ 'ਤੇ ਚੁੱਪ ਗਲਤੀ ਜਾਂ ਕਰੈਸ਼।
- ਸਰੋਤ/ਧਾਰਨਾ ਦਾ ਦਸਤਾਵੇਜ਼ੀਕਰਨ ਨਾ ਕਰਨਾ: ਵਰਤੇ ਗਏ ਫਾਰਮੂਲੇ ਦੇ ਸਰੋਤ ਅਤੇ ਧਾਰਨਾ ਨੂੰ ਨਾ ਲਿਖਣਾ।
- ਸੰਸਕਰਣ ਨਹੀਂ: ਖਾਤੇ ਨੂੰ ਟ੍ਰੇਸ ਕਰਨ ਯੋਗ ਬਣਾਏ ਬਿਨਾਂ ਇੱਕ-ਵਾਰ ਫਾਈਲ ਵਜੋਂ ਛੱਡਣਾ (ਗਿਟ)।
ਸੰਖੇਪ ਵਿੱਚ
- ਪਾਈਥਨ ਇੰਜਨੀਅਰਿੰਗ ਗਣਨਾ ਨੂੰ ਦੁਹਰਾਉਣ ਯੋਗ, ਖੋਜਣ ਯੋਗ, ਅਤੇ ਸੰਸਕਰਣ ਨਿਯੰਤਰਿਤ ਬਣਾਉਂਦਾ ਹੈ।
- AI ਕੋਡ ਬਣਾਉਣ ਵਿੱਚ ਬਹੁਤ ਤੇਜ਼ ਹੈ; ਪਰ ਇਹ ਤੱਥ ਕਿ ਕੋਡ ਗਲਤੀਆਂ ਤੋਂ ਬਿਨਾਂ ਕੰਮ ਕਰਦਾ ਹੈ ਇਸਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਹੈ ਕਿ ਇਹ ਸਹੀ ਢੰਗ ਨਾਲ ਗਣਨਾ ਕਰਦਾ ਹੈ.
- ਹਰ ਕੋਡ ਨੂੰ ਜਾਣਿਆ-ਪਛਾਣਿਆ-ਨਤੀਜਾ ਟੈਸਟਿੰਗ, ਯੂਨਿਟ ਚੈਕਿੰਗ, ਅਤੇ ਕਿਨਾਰੇ ਦੇ ਕੇਸਾਂ ਰਾਹੀਂ ਪ੍ਰਮਾਣਿਤ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।
- ਯੂਨਿਟ ਦੀਆਂ ਤਰੁੱਟੀਆਂ ਸਭ ਤੋਂ ਵੱਧ ਵਾਰ-ਵਾਰ ਅਤੇ ਸਭ ਤੋਂ ਧੋਖੇਬਾਜ਼ ਸਰੋਤ ਹਨ; ਸਿੰਗਲ ਯੂਨਿਟ ਸਿਸਟਮ, ਨਾਮਕਰਨ ਜਾਂ ਪਿੰਟ ਦੁਆਰਾ ਬਚਾਅ ਕਰੋ।
- ਪ੍ਰਮਾਣਿਤ ਆਟੋਮੇਸ਼ਨ ਸਮਾਂ ਬਚਾਉਂਦੀ ਹੈ ਅਤੇ ਵਿਸ਼ਵਾਸ ਦਿੰਦੀ ਹੈ; ਗੈਰ-ਪ੍ਰਮਾਣਿਤ ਕੋਡ ਖਤਰਨਾਕ ਹੈ।
ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਕੰਮ
ਇੱਕ ਆਵਰਤੀ ਇੰਜੀਨੀਅਰਿੰਗ ਗਣਨਾ ਚੁਣੋ (ਜਿਵੇਂ ਕਿ ਤਣਾਅ, ਪੰਪ ਪਾਵਰ, ਗਰਮੀ ਦਾ ਲੋਡ)। ਏਆਈ ਨੂੰ ਪਾਈਥਨ ਫੰਕਸ਼ਨ ਲਿਖੋ ਜੋ ਇਹ ਗਣਨਾ ਕਰਦਾ ਹੈ; ਹਰੇਕ ਇਨਪੁਟ ਅਤੇ ਆਉਟਪੁੱਟ ਦੀ ਇਕਾਈ ਨੂੰ ਟਿੱਪਣੀ ਕਰੋ ਅਤੇ ਇੱਕ ਜਾਣੇ-ਪਛਾਣੇ ਨਤੀਜੇ ਦੇ ਨਾਲ ਇੱਕ ਐਸਰਟ ਟੈਸਟ ਸ਼ਾਮਲ ਕਰੋ। ਟੈਸਟ ਚਲਾਓ ਅਤੇ ਦੇਖੋ ਕਿ ਕੀ ਇਹ ਪਾਸ ਹੁੰਦਾ ਹੈ. ਫਿਰ ਦੋ ਹੋਰ ਪੁਸ਼ਟੀਕਰਨ ਕਰੋ: ਇੱਕ ਕਿਨਾਰੇ ਕੇਸ (ਜ਼ੀਰੋ ਜਾਂ ਨਕਾਰਾਤਮਕ ਇਨਪੁਟ) ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਕੋਸ਼ਿਸ਼ ਕਰੋ ਕਿ ਕੋਡ ਇੱਕ ਮਹੱਤਵਪੂਰਣ ਗਲਤੀ ਦਿੰਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਉਦਾਹਰਨ ਵਿੱਚ ਆਉਟਪੁੱਟ ਦੀ ਇਕਾਈ ਨੂੰ ਹੱਥੀਂ ਪ੍ਰਦਾਨ ਕਰੋ। ਜੇ ਸੰਭਵ ਹੋਵੇ, ਤਾਂ ਪਿੰਟ ਵਿੱਚ ਇੱਕ ਯੂਨਿਟ-ਸੁਰੱਖਿਅਤ ਸੰਸਕਰਣ ਵੀ ਤਿਆਰ ਕਰੋ। ਅੰਤ ਵਿੱਚ, ਕੋਡ ਵਿੱਚ ਗਣਨਾ ਦੀਆਂ ਧਾਰਨਾਵਾਂ, ਫਾਰਮੂਲਾ ਸਰੋਤ, ਅਤੇ ਮਿਤੀ ਨੂੰ ਇੱਕ ਛੋਟੇ ਸਿਰਲੇਖ ਵਜੋਂ ਸ਼ਾਮਲ ਕਰੋ ਅਤੇ ਲਿਖੋ ਕਿ ਇਸ ਕੋਡ ਨੂੰ ਅਜੇ ਵੀ ਇੰਜੀਨੀਅਰ ਦੀ ਮਨਜ਼ੂਰੀ ਦੀ ਲੋੜ ਕਿਉਂ ਹੈ।
ਚੈੱਕਲਿਸਟ
- [ ] ਕੋਡ ਵਿੱਚ ਇੰਪੁੱਟ ਅਤੇ ਆਉਟਪੁੱਟ ਇਕਾਈਆਂ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਦਸਤਾਵੇਜ਼ੀ ਤੌਰ 'ਤੇ ਦਰਜ ਹਨ; ਸਿੰਗਲ ਯੂਨਿਟ ਸਿਸਟਮ ਨੂੰ ਚੁਣਿਆ ਗਿਆ ਸੀ.
- ਇੱਕ ਜਾਣੇ-ਪਛਾਣੇ ਨਤੀਜੇ ਦੇ ਨਾਲ ਇੱਕ ਟੈਸਟ (ਦਾਅ) ਜੋੜਿਆ ਗਿਆ ਅਤੇ ਪਾਸ ਕੀਤਾ ਗਿਆ।
- [ ] ਘੱਟੋ-ਘੱਟ ਇੱਕ ਕਿਨਾਰੇ ਕੇਸ (ਜ਼ੀਰੋ/ਨੈਗੇਟਿਵ) ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਗਈ ਸੀ; ਕੋਡ ਨੇ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਗਲਤੀ ਦਿੱਤੀ ਹੈ।
- ਆਉਟਪੁੱਟ ਦੀ ਇਕਾਈ ਇੱਕ ਦਸਤੀ ਉਦਾਹਰਨ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੀ ਗਈ ਸੀ (ਇਹ ਨਾ ਮੰਨ ਕੇ ਕਿ "worked = ਸਹੀ")।
- [ ] ਫਾਰਮੂਲਾ ਸਰੋਤ, ਧਾਰਨਾਵਾਂ ਅਤੇ ਮਿਤੀ ਕੋਡ ਵਿੱਚ ਨੋਟ ਕੀਤੀ ਗਈ ਹੈ।
- [ ] ਖਾਤਾ ਟਰੈਕ ਕਰਨ ਯੋਗ/ਟਰੈਕ ਕੀਤਾ ਗਿਆ; ਅੰਤਮ ਪ੍ਰਵਾਨਗੀ ਇੰਜੀਨੀਅਰ 'ਤੇ ਛੱਡ ਦਿੱਤੀ ਗਈ ਸੀ।