ਲਾਭ:
- ਮਜਬੂਤ SQL ਅਤੇ ਪਾਂਡਾ ਕੋਡ ਲੈਣ ਦੀ ਸਮਰੱਥਾ ਅਤੇ ਨਕਲੀ ਬੁੱਧੀ ਨੂੰ ਸਪਸ਼ਟ ਸਕੀਮਾ ਅਤੇ ਉਦੇਸ਼ ਦੇ ਕੇ ਲਾਈਨ ਦੁਆਰਾ ਇਸਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਤਸਦੀਕ ਕਰਨ ਦੀ ਸਮਰੱਥਾ
- ਰਲੇਵੇਂ/ਸ਼ਾਮਲ ਹੋਣ ਤੋਂ ਬਾਅਦ ਕਤਾਰਾਂ ਦੀ ਗਿਣਤੀ, ਫਿਟਿੰਗ ਫੰਕਸ਼ਨ ਅਤੇ ਥ੍ਰੋਪੁੱਟ ਵਰਗੀਆਂ ਚੁੱਪ ਦੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਫੜਨ ਦੀ ਸਮਰੱਥਾ
- ਇਸ ਨੂੰ ਚੁੱਪ ਕੀਤੇ ਬਿਨਾਂ ਡੀਬੱਗ ਵਿੱਚ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਅਤੇ ਉਤਪਾਦਨ ਵਾਤਾਵਰਣ ਵਿੱਚ ਇਸਦੀ ਜਾਂਚ ਕੀਤੇ ਬਿਨਾਂ ਕੋਡ ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਬਚੋ
ਡਾਟਾ ਸਾਇੰਸ ਦੀਆਂ ਦੋ ਪ੍ਰਾਇਮਰੀ ਭਾਸ਼ਾਵਾਂ ਹਨ: SQL (ਸਟ੍ਰਕਚਰਡ ਕਿਊਰੀ ਲੈਂਗੂਏਜ — ਡਾਟਾਬੇਸ ਤੋਂ ਡਾਟਾ ਪੁੱਛਣ ਲਈ ਭਾਸ਼ਾ) ਅਤੇ ਪਾਈਥਨ (ਖਾਸ ਤੌਰ 'ਤੇ, ਪਾਂਡਾ ਲਾਇਬ੍ਰੇਰੀ — ਟੇਬਲਾਂ ਨੂੰ ਪ੍ਰੋਗਰਾਮੇਟਿਕ ਤੌਰ 'ਤੇ ਹੇਰਾਫੇਰੀ ਕਰਨ ਲਈ ਸਟੈਂਡਰਡ ਟੂਲ)। ਇਸ ਯੂਨਿਟ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਕੋਡ ਪਾਰਟਨਰ ਵਜੋਂ AI ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸਿੱਖਾਂਗੇ: ਸਹੀ ਸਵਾਲਾਂ ਦੇ ਨਾਲ ਇਸ ਤੋਂ ਠੋਸ SQL ਅਤੇ ਪਾਂਡਾ ਕੋਡ ਪ੍ਰਾਪਤ ਕਰਨਾ, ਉਸ ਕੋਡ ਨੂੰ ਪੜ੍ਹਨਾ ਅਤੇ ਪ੍ਰਮਾਣਿਤ ਕਰਨਾ, ਇਸਨੂੰ ਡੀਬੱਗ ਕਰਨਾ, ਅਤੇ ਇਸਨੂੰ ਕਦੇ ਵੀ ਅੰਨ੍ਹੇਵਾਹ ਨਹੀਂ ਚਲਾਉਣਾ। AI ਮਿੰਟਾਂ ਦੀ ਬਜਾਏ ਸਕਿੰਟਾਂ ਵਿੱਚ ਦੁਹਰਾਉਣ ਵਾਲਾ ਕੋਡ ਲਿਖਦਾ ਹੈ; ਪਰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਤੁਹਾਡਾ ਕੰਮ ਹੈ ਕਿ ਇਹ ਜੋ ਕੋਡ ਤਿਆਰ ਕਰਦਾ ਹੈ ਉਹ ਸਹੀ ਤਰਕ ਨਾਲ ਸਹੀ ਕਾਲਮ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਦਾ ਹੈ। ਵਰਕਿੰਗ ਕੋਡ ਦਾ ਮਤਲਬ ਸਹੀ ਕੋਡ ਨਹੀਂ ਹੈ।
ਏਆਈ ਨਾਲ ਕੋਡ ਬਣਾਉਣਾ ਸ਼ਕਤੀਸ਼ਾਲੀ ਪਰ ਜੋਖਮ ਭਰਪੂਰ ਕਿਉਂ ਹੈ
AI ਕੋਡ ਜਨਰੇਸ਼ਨ ਵਿੱਚ ਤਿੰਨ ਵੱਡੇ ਫਾਇਦੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ: ਸਪੀਡ (ਸਕਿੰਟਾਂ ਵਿੱਚ ਇੱਕ 30-ਲਾਈਨ ਗਰੁੱਪਬਾਈ-ਪੀਵੋਟ ਓਪਰੇਸ਼ਨ ਲਿਖਦਾ ਹੈ), ਰੀਮਾਈਂਡਰ (ਤੁਹਾਨੂੰ ਇੱਕ ਪਾਂਡਾ ਫੰਕਸ਼ਨ ਦੀ ਯਾਦ ਦਿਵਾਉਂਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਭੁੱਲ ਗਏ ਹੋ), ਅਤੇ ਅਧਿਆਪਨ (ਲਾਈਨ ਦੁਆਰਾ ਕੋਡ ਲਾਈਨ ਦੀ ਵਿਆਖਿਆ ਕਰਦਾ ਹੈ)। ਪਰ ਇਸ ਵਿੱਚ ਤਿੰਨ ਜੋਖਮ ਹੁੰਦੇ ਹਨ: ਸਾਈਲੈਂਟ ਤਰਕ ਗਲਤੀ (ਕੋਡ ਜੋ ਗਲਤ ਕਾਲਮ ਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਤਰੁੱਟੀ ਦੇ ਚੱਲਦਾ ਹੈ), ਫਿੱਟ ਫੰਕਸ਼ਨ (ਇੱਕ ਵਿਧੀ ਦਾ ਸੁਝਾਅ ਦਿੰਦਾ ਹੈ ਜੋ ਮੌਜੂਦ ਨਹੀਂ ਹੈ), ਅਤੇ ਉਪਜ ਟ੍ਰੈਪ (ਕੋਡ ਜੋ ਛੋਟੇ ਡੇਟਾ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ ਪਰ 10 ਮਿਲੀਅਨ ਕਤਾਰਾਂ 'ਤੇ ਕ੍ਰੈਸ਼ ਹੁੰਦਾ ਹੈ)। ਇਸ ਲਈ ਸੁਨਹਿਰੀ ਨਿਯਮ: AI ਦੇ ਕੋਡ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਪੜ੍ਹੋ ਜਿਵੇਂ ਤੁਸੀਂ ਇਸਨੂੰ ਖੁਦ ਲਿਖਿਆ ਹੈ। ਉਹ ਲਾਈਨ ਨਾ ਚਲਾਓ ਜੋ ਤੁਸੀਂ ਨਹੀਂ ਸਮਝਦੇ.
SQL: ਸਰੋਤ 'ਤੇ ਡੇਟਾ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰੋ
SQL ਤੁਹਾਨੂੰ ਡੇਟਾਬੇਸ ਤੋਂ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਅਤੇ ਉੱਥੇ ਇਸਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ; ਤੁਸੀਂ ਉਨ੍ਹਾਂ ਨੂੰ ਪਾਈਥਨ ਵਿੱਚ ਖਿੱਚੇ ਬਿਨਾਂ ਲੱਖਾਂ ਲਾਈਨਾਂ ਦਾ ਸਾਰ ਦੇ ਸਕਦੇ ਹੋ। ਬੁਨਿਆਦੀ ਬਿਲਡਿੰਗ ਬਲਾਕ: ਚੁਣੋ (ਕਿਹੜੇ ਕਾਲਮ), ਕਿੱਥੇ (ਕਿਹੜੀਆਂ ਕਤਾਰਾਂ), GROUP BY (ਸਮੂਹ ਅਤੇ ਸੰਖੇਪ), JOIN (ਸਾਰੀਆਂ ਵਿੱਚ ਸ਼ਾਮਲ), ਹੋਣਾ (ਪੋਸਟ-ਗਰੁੱਪ ਫਿਲਟਰ)। AI ਗੁੰਝਲਦਾਰ JOIN ਅਤੇ ਵਿੰਡੋ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਲਿਖਣ ਵਿੱਚ ਬਹੁਤ ਮਦਦਗਾਰ ਹੈ, ਪਰ ਦੋ ਚੀਜ਼ਾਂ ਦੀ ਜਾਂਚ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ: ਕੀ ਸਹੀ ਕੁੰਜੀ (ਗਲਤ ਕੁੰਜੀ ਡੁਪਲੀਕੇਟ ਕਤਾਰਾਂ) ਰਾਹੀਂ ਜੁੜੋ ਅਤੇ ਫਿਲਟਰ ਤਰਕ ਸਹੀ ਹੈ (ਖਾਸ ਤੌਰ 'ਤੇ NULL ਵਿਵਹਾਰ ਅਤੇ ਮਿਤੀ ਰੇਂਜਾਂ)।
ਸਾਵਧਾਨ: ਉਤਪਾਦਨ ਡੇਟਾਬੇਸ ਦੇ ਵਿਰੁੱਧ ਸਿੱਧੇ ਤੌਰ 'ਤੇ AI ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੀ SQL ਪੁੱਛਗਿੱਛ ਨਾ ਚਲਾਓ। ਪਹਿਲਾਂ ਇੱਕ ਛੋਟੀ ਕਾਪੀ ਜਾਂ LIMIT ਨਾਲ ਟੈਸਟ ਕਰੋ। WHERE ਸ਼ਰਤ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕੀਤੇ ਬਿਨਾਂ ਕਦੇ ਵੀ UPDATE/DELETE ਪੁੱਛਗਿੱਛ ਨਾ ਚਲਾਓ; ਇੱਕ ਗਲਤ WHERE ਪੂਰੀ ਸਾਰਣੀ ਨੂੰ ਮਿਟਾ ਸਕਦਾ ਹੈ।
ਪਾਈਥਨ/ਪਾਂਡਾ: ਲਚਕਦਾਰ ਵਿਸ਼ਲੇਸ਼ਣ
ਪਾਂਡਾਸ ਪਾਈਥਨ ਵਿੱਚ ਟੇਬਲਾਂ (ਡੇਟਾਫ੍ਰੇਮ) ਨੂੰ ਹੇਰਾਫੇਰੀ ਕਰਨ ਦਾ ਮਿਆਰੀ ਤਰੀਕਾ ਹੈ। AI ਦੀ ਸਭ ਤੋਂ ਕੁਸ਼ਲ ਵਰਤੋਂ ਇਸ ਨੂੰ ਇੱਕ ਸਪਸ਼ਟ ਯੋਜਨਾ ਅਤੇ ਉਦੇਸ਼ ਦੇਣਾ ਹੈ। ਸਭ ਤੋਂ ਆਮ ਤੌਰ 'ਤੇ ਵਰਤੇ ਜਾਂਦੇ ਓਪਰੇਸ਼ਨ: ਫਿਲਟਰ, ਗਰੁੱਪਬਾਈ, ਮਰਜ, pivot_table, ਲਾਗੂ ਕਰੋ। AI ਇਹਨਾਂ ਨੂੰ ਜਲਦੀ ਲਿਖਦਾ ਹੈ; ਜੋ ਤੁਸੀਂ ਜਾਂਚਣਾ ਚਾਹੁੰਦੇ ਹੋ ਉਹ ਹੈ ਤਰਕ: ਕੀ ਸਹੀ ਕਾਲਮ ਵਿੱਚ ਗਰੁੱਪਿੰਗ ਹੈ, ਕੀ ਅਭੇਦ ਨੇ ਕਤਾਰਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਅਚਾਨਕ ਬਦਲ ਦਿੱਤਾ ਹੈ (ਹਮੇਸ਼ਾ ਅਭੇਦ ਹੋਣ ਤੋਂ ਬਾਅਦ ਕਤਾਰਾਂ ਦੀ ਸੰਖਿਆ ਦੀ ਜਾਂਚ ਕਰੋ), ਕੀ ਚੇਨ ਓਪਰੇਸ਼ਨ ਅਸਲ ਨੂੰ ਬਦਲ ਰਹੇ ਹਨ।
ਲੈਣ-ਦੇਣ
SQL
ਪਾਂਡਾ
ਚੌਕੀ
ਫਿਲਟਰਿੰਗ
ਕਿੱਥੇ
df[df.x > 5]
NULL/NaN ਵਿਵਹਾਰ
ਗਰੁੱਪਿੰਗ
ਗਰੁੱਪ ਦੁਆਰਾ
df.groupby()
ਕੀ ਇਹ ਸਹੀ ਕਾਲਮ ਹੈ?
ਅਭੇਦ
ਸ਼ਾਮਲ ਹੋਵੋ
df.merge()
ਕਤਾਰਾਂ ਦੀ ਗਿਣਤੀ ਵਿੱਚ ਤਬਦੀਲੀ
ਸੰਖੇਪ
AVG(), SUM()
.mean(), .sum()
ਕਿਹੜਾ ਕਾਲਮ ਇਕੱਠਾ ਕੀਤਾ ਗਿਆ ਸੀ
ਦੁਆਰਾ ਕ੍ਰਮਬੱਧ
ਦੁਆਰਾ ਆਰਡਰ ਕਰੋ
.sort_values()
ਦਿਸ਼ਾ (ਚੜ੍ਹਦਾ/ਉਤਰਦਾ)
ਡੁਪਲੀਕੇਸ਼ਨ
ਵੱਖਰਾ
.drop_duplicates()
ਕਿਹੜੇ ਕਾਲਮਾਂ ਵਿੱਚ?
ਡੀਬੱਗਿੰਗ: AI ਨਾਲ
ਜਦੋਂ ਕੋਡ ਫੇਲ ਹੁੰਦਾ ਹੈ, ਤਾਂ AI ਇੱਕ ਸ਼ਾਨਦਾਰ ਡੀਬਗਿੰਗ ਪਾਰਟਨਰ ਹੁੰਦਾ ਹੈ। ਇਸਨੂੰ ਪੂਰਾ ਗਲਤੀ ਸੁਨੇਹਾ ਅਤੇ ਸੰਬੰਧਿਤ ਕੋਡ ਸਨਿੱਪਟ ਦਿਓ। ਪਰ ਦੋ ਜਾਲਾਂ ਤੋਂ ਸਾਵਧਾਨ ਰਹੋ। ਪਹਿਲਾਂ, AI ਇੱਕ ਹੱਲ ਦਾ ਸੁਝਾਅ ਦੇ ਸਕਦਾ ਹੈ ਜੋ ਗਲਤੀ ਨੂੰ "ਚੁੱਪ" ਕਰਦਾ ਹੈ (ਉਦਾਹਰਨ ਲਈ, ਚੇਤਾਵਨੀਆਂ ਨੂੰ ਛੁਪਾਉਣਾ) - ਇਹ ਗਲਤੀ ਨੂੰ ਠੀਕ ਨਹੀਂ ਕਰਦਾ ਹੈ, ਇਹ ਇਸਨੂੰ ਲੁਕਾਉਂਦਾ ਹੈ। ਦੂਜਾ, ਏਆਈ ਕਦੇ-ਕਦਾਈਂ ਕਿਸੇ ਸਮੱਸਿਆ ਨੂੰ "ਹੱਲ" ਕਰਦੇ ਹੋਏ ਚੁੱਪਚਾਪ ਕਿਸੇ ਹੋਰ ਵਿਵਹਾਰ ਨੂੰ ਬਦਲਦਾ ਹੈ। ਨਿਯਮ: ਫਿਕਸ ਨੂੰ ਸਮਝੋ, ਮਿਊਟ ਨਾ ਕਰਨ ਦਾ ਹੱਲ ਕਰੋ, ਅਤੇ ਪੁਸ਼ਟੀ ਕਰੋ ਕਿ ਫਿਕਸ ਤੋਂ ਬਾਅਦ ਵੀ ਆਉਟਪੁੱਟ ਸਹੀ ਹੈ।
ਵਿਆਖਿਆਯੋਗ ਅਤੇ ਸਾਂਭਣਯੋਗ ਕੋਡ ਚਾਹੁੰਦੇ ਹਨ
AI ਤੋਂ ਕੋਡ ਖਰੀਦਣ ਵੇਲੇ, ਉਹ ਕੋਡ ਮੰਗੋ ਜੋ ਪੜ੍ਹਨਯੋਗ ਅਤੇ ਸਾਂਭਣਯੋਗ ਹੋਵੇ, ਨਾ ਕਿ ਸਿਰਫ਼ ਉਹ ਕੋਡ ਜੋ "ਕੰਮ ਕਰਦਾ ਹੈ"। ਜਦੋਂ ਤੁਸੀਂ ਜਾਂ ਕੋਈ ਸਹਿਕਰਮੀ ਉਸ ਕੋਡ ਨੂੰ ਮਹੀਨਿਆਂ ਬਾਅਦ ਖੋਲ੍ਹਦਾ ਹੈ, ਤਾਂ ਇਹ ਸਮਝਣ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਇਹ ਕੀ ਕਰਦਾ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, AI ਵਿੱਚ ਤਿੰਨ ਚੀਜ਼ਾਂ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਆਦਤ ਬਣਾਓ: ਅਰਥਪੂਰਨ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਾਮ (orders_temiz, df2 ਨਹੀਂ), ਨਾਜ਼ੁਕ ਕਦਮਾਂ 'ਤੇ ਛੋਟੀ ਟਿੱਪਣੀ ਲਾਈਨਾਂ (ਇਹ ਸਮਝਾਉਣਾ ਕਿ ਕਿਉਂ, ਕੀ ਨਹੀਂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ), ਅਤੇ ਇੱਕ ਮੈਜਿਕ ਨੰਬਰ ਦੀ ਬਜਾਏ ਇੱਕ ਨਾਮਿਤ ਸਥਿਰ (ACCEPT_ESIGI = 0.85 ਦੀ ਬਜਾਏ eduri b in the code)। ਲੰਬੀਆਂ ਸਿੰਗਲ-ਲਾਈਨ ਚੇਨਾਂ ਤੋਂ ਵੀ ਬਚੋ (ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਪੰਜ ਕਿਰਿਆਵਾਂ ਨੂੰ ਜੋੜਨਾ); ਇਹ ਡੀਬੱਗਿੰਗ ਨੂੰ ਮੁਸ਼ਕਲ ਬਣਾਉਂਦੇ ਹਨ। ਮੂਲ ਰੂਪ ਵਿੱਚ, AI ਅਕਸਰ ਸੰਖੇਪ ਅਤੇ "ਸਮਾਰਟ" ਕੋਡ ਪੈਦਾ ਕਰਦਾ ਹੈ; ਜੇਕਰ ਤੁਸੀਂ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਕਹਿੰਦੇ ਹੋ ਕਿ "ਪੜ੍ਹਨਯੋਗ, ਵਿਆਖਿਆਯੋਗ, ਸਾਂਭਣਯੋਗ ਲਿਖੋ", ਤਾਂ ਤੁਹਾਨੂੰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਸਾਂਭਣਯੋਗ ਆਉਟਪੁੱਟ ਮਿਲੇਗੀ। ਇਹ ਰੀਪ੍ਰੋਡਸੀਬਿਲਟੀ (ਯੂਨਿਟ 10) ਦਾ ਆਧਾਰ ਵੀ ਹੈ: ਜੋ ਕੋਡ ਸਮਝਿਆ ਨਹੀਂ ਜਾਂਦਾ ਉਹ ਕੋਡ ਹੁੰਦਾ ਹੈ ਜਿਸ ਨੂੰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਦੁਬਾਰਾ ਨਹੀਂ ਚਲਾਇਆ ਜਾ ਸਕਦਾ।
ਤਿੰਨ ਛੋਟੇ ਕੇਸ
ਕੇਸ 1 - ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਵੋ। ਇੱਕ ਵਿਸ਼ਲੇਸ਼ਕ ਨੇ ਉਤਪਾਦ ਸਾਰਣੀ ਦੇ ਨਾਲ ਆਦੇਸ਼ਾਂ ਨੂੰ ਜੋੜਿਆ ਅਤੇ ਕੁੱਲ ਟਰਨਓਵਰ 3 ਗੁਣਾ ਵੱਧ ਪਾਇਆ। ਕਾਰਨ: ਉਤਪਾਦ ਸਾਰਣੀ ਵਿੱਚ ਹਰੇਕ ਉਤਪਾਦ ਦੀਆਂ ਕਈ ਕਤਾਰਾਂ (ਵੱਖ-ਵੱਖ ਰੰਗ) ਸਨ; ਹਰੇਕ ਆਰਡਰ ਦੀ ਡੁਪਲੀਕੇਟ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਵੋ। AI ਦਾ ਕੋਡ "ਕੰਮ ਕਰ ਰਿਹਾ ਸੀ", ਪਰ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ 240 ਹਜ਼ਾਰ ਤੋਂ 690 ਹਜ਼ਾਰ ਹੋ ਗਈ ਸੀ। ਪਾਠ: ਅਭੇਦ/ਸ਼ਾਮਲ ਹੋਣ ਤੋਂ ਬਾਅਦ ਹਮੇਸ਼ਾ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਜਾਂਚ ਕਰੋ।
ਕੇਸ 2 - ਫਿਟਿੰਗ ਫੰਕਸ਼ਨ। ਉਸਨੇ ਇੱਕ ਇੰਟਰਨ ਨੂੰ AI df.groupby('x').summarize() ਦਾ ਸੁਝਾਅ ਦਿੱਤਾ; ਪਾਂਡਾ ਵਿੱਚ ਅਜਿਹਾ ਕੋਈ ਤਰੀਕਾ ਨਹੀਂ ਹੈ (.agg() ਹੈ)। ਕੋਡ ਕੰਮ ਨਹੀਂ ਕਰਦਾ, ਇੰਟਰਨ 20 ਮਿੰਟਾਂ ਲਈ ਗੁੰਮ ਹੋ ਗਿਆ ਸੀ। ਪਾਠ: ਇੱਕ ਫੰਕਸ਼ਨ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ ਜਿਸ ਨੂੰ ਤੁਸੀਂ ਦਸਤਾਵੇਜ਼ ਤੋਂ ਨਹੀਂ ਪਛਾਣਦੇ ਹੋ; AI ਤਰੀਕੇ ਬਣਾ ਸਕਦੇ ਹਨ।
ਕੇਸ 3 - ਉਪਜ ਦਾ ਪਤਨ। ਇੱਕ ਕੋਡ ਹਰੇਕ ਕਤਾਰ ਲਈ ਅਰਜ਼ੀ ਵਿੱਚ ਡੇਟਾਬੇਸ ਦੀ ਪੁੱਛਗਿੱਛ ਕਰ ਰਿਹਾ ਸੀ; ਇਹ 5,000 ਲਾਈਨਾਂ 'ਤੇ ਚੱਲਿਆ, 4 ਮਿਲੀਅਨ ਲਾਈਨਾਂ 'ਤੇ 9 ਘੰਟੇ ਲੱਗ ਗਏ, ਅਤੇ ਰੁਕ ਗਏ। ਜਦੋਂ AI ਨੇ ਵੈਕਟਰਾਈਜ਼ਡ (ਬੈਚ) ਹੱਲ ਦਾ ਸੁਝਾਅ ਦਿੱਤਾ, ਤਾਂ ਸਮਾਂ ਘਟਾ ਕੇ 40 ਸਕਿੰਟ ਕਰ ਦਿੱਤਾ ਗਿਆ। ਸਬਕ: ਛੋਟੇ ਡੇਟਾ ਤੇ ਕੰਮ ਕਰਨ ਵਾਲਾ ਕੋਡ ਵੱਡੇ ਡੇਟਾ ਤੇ ਕ੍ਰੈਸ਼ ਹੋ ਸਕਦਾ ਹੈ; ਕੁਸ਼ਲਤਾ 'ਤੇ ਗੌਰ ਕਰੋ.
ਚਾਰ ਕਾਪੀ ਕਰਨ ਯੋਗ ਟੈਂਪਲੇਟ
1) ਸਕੀਮਾ ਨਾਲ SQL ਦੀ ਬੇਨਤੀ ਕਰਨਾ:
ਤੁਹਾਡੀ ਭੂਮਿਕਾ: SQL ਸਹਾਇਕ (PostgreSQL)। ਟੇਬਲ: - ਆਰਡਰ (id, customer_id, ਮਿਤੀ ਟਾਈਮਸਟੈਂਪ, ਰਕਮ ਸੰਖਿਆਤਮਕ)- ਗਾਹਕ (id, ਸ਼ਹਿਰ ਦਾ ਟੈਕਸਟ) ਟਾਸਕ: 2024 ਵਿੱਚ ਪ੍ਰਤੀ ਸ਼ਹਿਰ ਕੁੱਲ ਟਰਨਓਵਰ ਅਤੇ ਆਰਡਰਾਂ ਦੀ ਗਿਣਤੀ ਪ੍ਰਾਪਤ ਕਰੋ, ਘਟਦੇ ਕ੍ਰਮ ਵਿੱਚ ਟਰਨਓਵਰ ਦੁਆਰਾ ਕ੍ਰਮਬੱਧ। ਦੱਸੋ ਕਿ ਤੁਸੀਂ NULL ਸ਼ਹਿਰਾਂ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਦੇ ਹੋ। ਮੈਂ ਪਹਿਲਾਂ LIMIT ਨਾਲ ਪੁੱਛਗਿੱਛ ਦੀ ਜਾਂਚ ਕਰਾਂਗਾ; ਪੀੜ੍ਹੀ ਨੂੰ ਅੱਪਡੇਟ/ਮਿਟਾਓ।
2) ਚੈਕਪੁਆਇੰਟ ਨਾਲ ਪਾਂਡਾ ਪ੍ਰਕਿਰਿਆ:
ਮੇਰੇ ਕੋਲ DataFrames df (ਆਰਡਰ) ਅਤੇ df_customers (ਗਾਹਕ) ਹਨ। ਪ੍ਰਤੀ ਸ਼ਹਿਰ ਔਸਤ ਰਕਮ ਦੀ ਗਣਨਾ ਕਰੋ। ਮਹੱਤਵਪੂਰਨ: ਰਲੇਵੇਂ ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਕਤਾਰਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰੋ ਤਾਂ ਜੋ ਮੈਂ ਦੇਖ ਸਕਾਂ ਕਿ ਕੀ ਡੁਪਲੀਕੇਸ਼ਨ ਹੈ। ਦੱਸੋ ਕਿ ਤੁਸੀਂ ਕਿਸ ਕਾਲਮ ਵਿੱਚ ਮਿਲਾਇਆ ਹੈ ਅਤੇ ਤੁਸੀਂ ਅੰਦਰੂਨੀ/ਖੱਬੇ ਕਿਉਂ ਚੁਣਿਆ ਹੈ।
3) ਕੋਡ ਦੀ ਵਿਆਖਿਆ ਅਤੇ ਤਸਦੀਕ:
ਹੇਠਾਂ ਦਿੱਤੀ ਪਾਂਡਾ ਕੋਡ ਲਾਈਨ ਨੂੰ ਲਾਈਨ ਦੁਆਰਾ ਸਮਝਾਓ: ਹਰੇਕ ਲਾਈਨ ਕੀ ਕਰਦੀ ਹੈ, ਇਹ ਕਿਹੜੀਆਂ ਧਾਰਨਾਵਾਂ ਬਣਾਉਂਦੀ ਹੈ, ਕਿਨ੍ਹਾਂ ਮਾਮਲਿਆਂ ਵਿੱਚ ਇਹ ਗਲਤ ਨਤੀਜੇ ਦੇ ਸਕਦੀ ਹੈ? ਮੈਨੂੰ ਦੱਸੋ ਕਿ ਕੀ ਮੈਂ ਫਜ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ। ਕੋਡ: [ਪੇਸਟ]
4) ਡੀਬੱਗਿੰਗ:
ਇਹ ਕੋਡ ਇਹ ਗਲਤੀ ਦਿੰਦਾ ਹੈ। ਪੂਰਾ ਗਲਤੀ ਸੁਨੇਹਾ: [ਪੇਸਟ]। ਕੋਡ: [ਪੇਸਟ]। ਗਲਤੀ ਦੇ ਮੂਲ ਕਾਰਨ ਦੀ ਵਿਆਖਿਆ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਠੀਕ ਕਰੋ। ਇਸ ਨੂੰ ਅਸਲ ਵਿੱਚ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਕੇ ਹੱਲ ਕਰੋ, ਚੇਤਾਵਨੀ ਨੂੰ ਚੁੱਪ ਕਰਕੇ ਨਹੀਂ। ਇਹ ਵੀ ਦੱਸੋ ਕਿ ਕੀ ਫਿਕਸ ਨੇ ਆਉਟਪੁੱਟ ਨੂੰ ਬਦਲਿਆ ਹੈ।
ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ / ਮਜ਼ਬੂਤ ਪ੍ਰੋਂਪਟ
ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ:
ਇੱਕ ਸਵਾਲ ਲਿਖੋ ਜੋ ਮੈਨੂੰ ਪ੍ਰਤੀ ਸ਼ਹਿਰ ਵਿਕਰੀ ਦਿੰਦਾ ਹੈ।
ਸਾਰਣੀ ਦੇ ਨਾਮ, ਕਾਲਮ, ਡੇਟਾਬੇਸ ਕਿਸਮ, NULL ਵਿਵਹਾਰ ਅਸਪਸ਼ਟ ਹਨ। AI ਆਮ ਹੈ, ਇਹ ਸੰਭਵ ਤੌਰ 'ਤੇ ਇੱਕ ਪੁੱਛਗਿੱਛ ਪੈਦਾ ਕਰੇਗਾ ਜੋ ਤੁਹਾਡੀ ਸਾਰਣੀ ਵਿੱਚ ਫਿੱਟ ਨਹੀਂ ਬੈਠਦਾ ਹੈ।
ਸ਼ਕਤੀਸ਼ਾਲੀ ਪ੍ਰਾਉਟ:
ਤੁਹਾਡੀ ਭੂਮਿਕਾ: SQL ਸਹਾਇਕ (MySQL 8)। ਸਾਰਣੀ: ਵਿਕਰੀ (ਆਈਡੀ, ਸਿਟੀ ਵਰਚਰ, ਰਕਮ ਦਸ਼ਮਲਵ, ਮਿਤੀ ਮਿਤੀ)। ਟਾਸਕ: ਸਾਲ 2024 ਲਈ ਕੁੱਲ ਅਤੇ ਔਸਤ ਰਕਮ, ਪ੍ਰਤੀ ਸ਼ਹਿਰ ਦੇ ਆਦੇਸ਼ਾਂ ਦੀ ਗਿਣਤੀ ਪ੍ਰਾਪਤ ਕਰੋ; ਕੁੱਲ ਰਕਮ ਦੁਆਰਾ ਘਟਦੀ ਛਾਂਟੀ; ਸਿਰਫ਼ 100 ਤੋਂ ਵੱਧ ਆਰਡਰ (HAVING) ਵਾਲੇ ਸ਼ਹਿਰ ਦਿਖਾਓ। NULL ਸ਼ਹਿਰ ਨੂੰ ਬਾਹਰ ਕੱਢੋ। ਸਵਾਲ ਦੀ ਵਿਆਖਿਆ ਕਰੋ; ਮੈਂ LIMIT ਨਾਲ ਟੈਸਟ ਕਰਾਂਗਾ।
ਇੱਥੇ ਡਾਟਾਬੇਸ, ਸਕੀਮਾ, ਫਿਲਟਰ, ਲੜੀਬੱਧ ਅਤੇ NULL ਨਿਯਮ ਸਪੱਸ਼ਟ ਹਨ।
ਆਮ ਗਲਤੀਆਂ
- ਕੋਡ ਨੂੰ ਪੜ੍ਹੇ ਬਿਨਾਂ ਚੱਲ ਰਿਹਾ ਹੈ। ਵਰਕਿੰਗ ਕੋਡ ਸਹੀ ਕੋਡ ਨਹੀਂ ਹੈ; ਕੋਡ ਜੋ ਗਲਤ ਕਾਲਮ ਨੂੰ ਹੇਰਾਫੇਰੀ ਕਰਦਾ ਹੈ ਉਹ ਵੀ ਗਲਤੀਆਂ ਤੋਂ ਬਿਨਾਂ ਚੱਲਦਾ ਹੈ।
- ਅਭੇਦ/ਸ਼ਾਮਲ ਹੋਣ ਤੋਂ ਬਾਅਦ ਕਤਾਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਜਾਂਚ ਨਹੀਂ ਕੀਤੀ ਜਾ ਰਹੀ। ਗਲਤ ਕੁੰਜੀ ਚੁੱਪਚਾਪ ਕਤਾਰਾਂ ਦੀ ਡੁਪਲੀਕੇਟ ਬਣਾਉਂਦੀ ਹੈ ਅਤੇ ਕੁੱਲਾਂ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈ।
- ਫਿਟਿੰਗ ਫੰਕਸ਼ਨ ਦੀ ਪੁਸ਼ਟੀ ਨਹੀਂ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ। AI ਉਹਨਾਂ ਤਰੀਕਿਆਂ ਦਾ ਸੁਝਾਅ ਦੇ ਸਕਦਾ ਹੈ ਜੋ ਮੌਜੂਦ ਨਹੀਂ ਹਨ; ਦਸਤਾਵੇਜ਼ ਤੋਂ ਪੁਸ਼ਟੀ ਕਰੋ ਕਿ ਤੁਸੀਂ ਇਸਨੂੰ ਨਹੀਂ ਪਛਾਣਦੇ.
- ਕੁਸ਼ਲਤਾ ਬਾਰੇ ਨਹੀਂ ਸੋਚਣਾ. ਲੱਖਾਂ ਕਤਾਰਾਂ 'ਤੇ ਛੋਟੇ ਡੇਟਾ ਕ੍ਰੈਸ਼ਾਂ 'ਤੇ ਕੰਮ ਕਰਨ ਲਈ ਲਾਗੂ/ਲੂਪ; ਵੈਕਟਰਾਈਜ਼
- ਉਤਪਾਦਨ ਡਾਟਾਬੇਸ 'ਤੇ ਸਿੱਧਾ ਚਲਾਓ. ਖਾਸ ਤੌਰ 'ਤੇ UPDATE/DELETE ਨੂੰ WHERE ਜਾਂ ਟੈਸਟਿੰਗ ਤੋਂ ਬਿਨਾਂ ਚਲਾਉਣਾ ਵਿਨਾਸ਼ਕਾਰੀ ਹੈ।
ਸੁਝਾਅ: AI ਤੋਂ ਤੁਹਾਨੂੰ ਪ੍ਰਾਪਤ ਹੋਣ ਵਾਲੇ ਕੋਡ ਦੇ ਹਰੇਕ ਹਿੱਸੇ ਵਿੱਚ ਇੱਕ "ਪ੍ਰਮਾਣਿਕਤਾ ਲਾਈਨ" ਜੋੜਨ ਦੀ ਆਦਤ ਪਾਓ: ਲਾਈਨਾਂ ਦੀ ਇੱਕ ਪ੍ਰੀ- ਅਤੇ ਪੋਸਟ-ਪ੍ਰੋਸੈਸਿੰਗ ਸੰਖਿਆ, ਕੁਝ ਨਮੂਨਾ ਲਾਈਨਾਂ, ਅਤੇ ਹੱਥ ਦੁਆਰਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਕੁੱਲ। ਇਹ ਤਿੰਨ ਜਾਂਚਾਂ ਸਭ ਤੋਂ ਚੁੱਪ ਤਰਕ ਦੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਫੜਦੀਆਂ ਹਨ।
ਸੰਖੇਪ ਵਿੱਚ
AI ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਸਹਿਭਾਗੀ ਹੈ ਜੋ ਜਲਦੀ ਹੀ SQL ਅਤੇ ਪਾਂਡਾ ਕੋਡ ਬਣਾਉਂਦਾ ਹੈ, ਪਰ ਇਹ ਇੱਕ ਅੰਨ੍ਹਾ ਅਧਿਕਾਰ ਨਹੀਂ ਹੈ। ਉਸਨੂੰ ਸਪਸ਼ਟ ਤੌਰ ਤੇ ਯੋਜਨਾ ਅਤੇ ਉਦੇਸ਼ ਦਿਓ; ਇਸ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਗਏ ਕੋਡ ਨੂੰ ਪੜ੍ਹੋ ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਇਸਨੂੰ ਖੁਦ ਲਿਖਿਆ ਹੈ; ਰਲੇਵੇਂ/ਸ਼ਾਮਲ ਹੋਣ ਤੋਂ ਬਾਅਦ ਕਤਾਰਾਂ ਦੀ ਗਿਣਤੀ, ਫਿਟਿੰਗ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਥ੍ਰੋਪੁੱਟ ਦੀ ਜਾਂਚ ਕਰੋ; ਇਸ ਨੂੰ ਉਤਪਾਦਨ ਡੇਟਾਬੇਸ 'ਤੇ ਜਾਂਚ ਕੀਤੇ ਬਿਨਾਂ ਨਾ ਚਲਾਓ। ਡੀਬੱਗਿੰਗ ਕਰਦੇ ਸਮੇਂ, ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਦਾ ਟੀਚਾ ਰੱਖੋ, ਇਸ ਨੂੰ ਚੁੱਪ ਨਾ ਕਰੋ। ਕੰਮ ਕਰਨ ਵਾਲਾ ਕੋਡ ਸਹੀ ਕੋਡ ਨਹੀਂ ਹੈ; ਸਿਰਫ਼ ਤੁਸੀਂ ਹੀ ਸ਼ੁੱਧਤਾ ਦੀ ਗਰੰਟੀ ਦੇ ਸਕਦੇ ਹੋ।
ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਕੰਮ
ਇੱਕ ਵਿਸ਼ਲੇਸ਼ਣ ਪ੍ਰਸ਼ਨ ਚੁਣੋ (ਜਿਵੇਂ ਕਿ “ਪ੍ਰਤੀ ਚੈਨਲ ਮਾਸਿਕ ਟਰਨਓਵਰ”) ਅਤੇ SQL ਅਤੇ ਪਾਂਡਾ ਦੋਵਾਂ ਨਾਲ AI ਤੋਂ ਕੋਡ ਦੀ ਬੇਨਤੀ ਕਰੋ। ਦੋਵੇਂ ਕੋਡ ਲਾਈਨਾਂ ਨੂੰ ਲਾਈਨ ਦੁਆਰਾ ਪੜ੍ਹੋ, ਅਭੇਦ/ਸ਼ਾਮਲ ਹੋਣ ਤੋਂ ਬਾਅਦ ਲਾਈਨਾਂ ਦੀ ਸੰਖਿਆ ਦੀ ਜਾਂਚ ਕਰੋ ਅਤੇ ਘੱਟੋ-ਘੱਟ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਰਕਮ ਦੀ ਦਸਤੀ ਪੁਸ਼ਟੀ ਕਰੋ। ਤੁਲਨਾ ਕਰੋ ਕਿ ਕੀ ਦੋ ਕੋਡ ਇੱਕੋ ਨਤੀਜੇ ਦਿੰਦੇ ਹਨ; ਜੇ ਵੱਖਰਾ ਹੈ, ਤਾਂ ਪਤਾ ਕਰੋ ਕਿ ਕਿਉਂ।
ਚੈੱਕਲਿਸਟ
- ਕੀ ਮੈਂ ਏਆਈ ਨੂੰ ਸਾਰਣੀ/ਸਕੀਮਾ ਅਤੇ ਉਦੇਸ਼ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਦਿੱਤੇ ਹਨ?
- [ ] ਕੀ ਮੈਂ ਉਸ ਕੋਡ ਨੂੰ ਪੜ੍ਹਿਆ ਅਤੇ ਸਮਝਿਆ ਜੋ ਇਸ ਨੇ ਲਾਈਨ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤਾ ਸੀ?
- ਕੀ ਮੈਂ ਮਰਜ/ਸ਼ਾਮਲ ਹੋਣ ਤੋਂ ਬਾਅਦ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਜਾਂਚ ਕੀਤੀ ਹੈ?
- [ ] ਕੀ ਮੈਂ ਉਹਨਾਂ ਫੰਕਸ਼ਨਾਂ ਦੀ ਪੁਸ਼ਟੀ ਕੀਤੀ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਮੈਂ ਦਸਤਾਵੇਜ਼ਾਂ ਤੋਂ ਨਹੀਂ ਪਛਾਣਦਾ?
- [ ] ਕੀ ਮੈਂ ਕੋਡ ਨੂੰ ਪਹਿਲਾਂ ਸੁਰੱਖਿਅਤ/ਛੋਟੇ ਡੇਟਾ ਤੇ ਟੈਸਟ ਕੀਤਾ ਹੈ ਨਾ ਕਿ ਉਤਪਾਦਨ ਵਾਤਾਵਰਣ ਵਿੱਚ?